Anki's Great Refactor

Picture your most critical production service. Written by a single brilliant engineer nearly two decades ago. Millions of requests handled flawlessly. But only one person truly understands its internals. Documentation is sparse. Every feature request funnels through their personal inbox. Bus factor of one.

For years, Anki has been exactly this: a testament to its creator, Damien Elmes, but also a system teetering on a single point of failure. The recent leadership transfer to the AnkiHub team is the most important refactoring in the project's history. A shift from a fragile, single-threaded process to a resilient, community-driven, distributed system.

The bus factor problem

A project's success, when tied to a single individual, becomes its biggest vulnerability. This isn't a criticism. It's a testament to their dedication that the system thrived so long. But the model is unsustainable. It creates a bottleneck for innovation and a single point of failure.

In code terms, it's a singleton gone wild:

class MonolithicOpenSourceProject {
  private readonly soleMaintainer: string;
  private features: Set<string>;
 
  constructor(founder: string) {
    this.soleMaintainer = founder;
    this.features = new Set(["core-logic", "basic-ui"]);
    console.log(`All operations depend on ${this.soleMaintainer}. Bus Factor: 1.`);
  }
 
  public proposeChange(feature: string, author: string): boolean {
    if (author === this.soleMaintainer) {
      this.features.add(feature);
      console.log(`${this.soleMaintainer} approved '${feature}'.`);
      return true;
    } else {
      console.log(`Proposal for '${feature}' by ${author} is pending review by ${this.soleMaintainer}.`);
      return false;
    }
  }
}
 
const ankiLegacy = new MonolithicOpenSourceProject("Damien Elmes");
ankiLegacy.proposeChange("default-fsrs-algorithm", "CommunityContributor");
// Proposal pending review by Damien Elmes.

This single-threaded governance manifests in predictable ways:

Technical debt accrual: UI/UX improvements languish because they aren't the maintainer's focus. The interface gets dated, raising the barrier for new users.
Innovation bottlenecks: The long debate over replacing SM2 with FSRS is a case study. When decisions rest on one person's bandwidth, even well-supported initiatives stall.
High contributor barrier: Without clear governance, contributors get discouraged. The effort to understand the codebase and get a PR reviewed becomes too high.

Anki didn't outgrow its code architecture. It outgrew its human architecture.

The refactor: governance and systems

The transfer to AnkiHub addresses this scaling problem through three areas.

Distributing ownership

The most crucial step: expanding the core team. Bringing in the AnkiHub team and David Allison, the AnkiDroid maintainer, immediately multiplies the bus factor. Knowledge once locked in one person's head is now shared across backend Rust, Android development, and UI/UX expertise.

Defining a contribution API

A healthy open-source project needs a clear process for contributions. The new team's stated goals (better documentation, predictable release cycles, clear addon API) all lower the barrier to entry. When contributors know their efforts won't disappear into a void, they participate.

Transparent governance

The move from implicit individual decisions to an explicit governance structure is the biggest change. The new leadership has pointed to Python's PEP system as a model. Major changes debated openly, documented, decided by a defined group with community input.

The code analogy, refactored:

interface Contributor {
  id: string;
  expertise: string[];
}
 
interface GovernanceProposal {
  id: string;
  title: string;
  authorId: string;
  status: 'pending' | 'approved' | 'rejected';
  votes: Map<string, 'for' | 'against'>;
}
 
class SustainableOpenSourceProject {
  private governanceBoard: Map<string, Contributor>;
  public features: Set<string>;
  private proposals: Map<string, GovernanceProposal> = new Map();
 
  constructor(initialBoard: Contributor[]) {
    this.governanceBoard = new Map(initialBoard.map(c => [c.id, c]));
    this.features = new Set(["core-logic", "basic-ui"]);
    console.log(`Governance board established. Bus Factor: ${this.governanceBoard.size}.`);
  }
 
  public submitProposal(title: string, author: Contributor): GovernanceProposal {
    const proposalId = `prop-${Date.now()}`;
    const newProposal: GovernanceProposal = {
      id: proposalId, title, authorId: author.id,
      status: 'pending', votes: new Map()
    };
    this.proposals.set(proposalId, newProposal);
    console.log(`${author.id} submitted proposal: "${title}".`);
    return newProposal;
  }
 
  public voteOnProposal(proposalId: string, memberId: string, vote: 'for' | 'against'): void {
    if (!this.governanceBoard.has(memberId)) return;
    const proposal = this.proposals.get(proposalId);
    if (!proposal) return;
 
    proposal.votes.set(memberId, vote);
    this.resolveProposal(proposal);
  }
 
  private resolveProposal(proposal: GovernanceProposal): void {
    const votesFor = Array.from(proposal.votes.values()).filter(v => v === 'for').length;
    if (votesFor > this.governanceBoard.size / 2) {
      proposal.status = 'approved';
      this.features.add(proposal.title);
      console.log(`Proposal "${proposal.title}" approved and merged.`);
    }
  }
}
 
const damien: Contributor = { id: 'Damien', expertise: ['core-backend', 'desktop'] };
const david: Contributor = { id: 'David', expertise: ['android', 'rust'] };
const designer: Contributor = { id: 'JaneDoe', expertise: ['ui-ux'] };
 
const ankiNext = new SustainableOpenSourceProject([damien, david, designer]);
const fsrsProposal = ankiNext.submitProposal('default-fsrs-algorithm', david);
 
ankiNext.voteOnProposal(fsrsProposal.id, 'David', 'for');
ankiNext.voteOnProposal(fsrsProposal.id, 'JaneDoe', 'for');
// Proposal "default-fsrs-algorithm" approved and merged.

Risks and trade-offs

Enshittification

The fear that a beloved tool gets degraded by commercial interests. Valid concern. But Anki has a built-in defense: its AGPL license. The code and any modifications must remain open source. If the new leadership takes a user-hostile direction, the community can fork the project and continue development.

AnkiHub is self-funded and explicitly rejects VC money. This removes the primary driver of enshittification: investor pressure for exponential growth at any cost.

Governance vacuum

The new team has been honest: they don't have the governance model fully mapped out. Some see this as unprepared. I see it as an agile approach. Instead of dictating rules top-down, they're inviting the community to help build the process. Messier in the short term, more likely to produce a system the community actually supports.

Ecosystem fragmentation

Anki is an ecosystem: Desktop, AnkiMobile, AnkiWeb, AnkiDroid. Fractured leadership could mean divergent development and a broken user experience. Bringing AnkiDroid's lead developer onto the core team aligns the major platforms under a shared vision. The new Rust backend benefits everyone. This prevents a potential schism.

A new architecture

The transfer addresses the single greatest existential threat to Anki: its bus factor of one. Success isn't guaranteed. Building a community-led open-source project is hard. But the principles are sound: increase the bus factor, establish transparent governance, lower the contribution barrier, maintain financial independence.

The team's honesty about what they don't know yet is more reassuring than any overconfident roadmap. They're building the plane while flying it, with the entire community invited as co-pilots.