Tools

Zigzag vs Arc: Can a 3-Week Browser Replace It?

Shanghai high school student Zigao Wang built Zigzag, an open-source macOS browser using Swift and WebKit. It preserves Arc's familiar top-tab workflow but still lacks the infrastructure needed for long-term use, including extension compatibility, syncing, and sustained security maintenance.

Font size

Arc is shutting down.

The Browser Company has announced that it will cease operations on December 22. For users accustomed to top tabs, Command-T search, and keyboard-driven navigation, the problem is not simply losing another browser. Their established workflow has lost its home.

Zigao Wang is a high school student from Shanghai. He built Zigzag in roughly three weeks and published the project on the front page of Hacker News.

This is not a corporate project, and it has no long-term maintenance team. Zigzag is better understood as a focused demand sample: someone who wanted neither Chromium nor AI built into the browser.

Project repository: https://github.com/ZigaoWang/zigzag

Arc's Shutdown Leads to a Three-Week Alternative

Zigao wrote in his Show HN post that he built Zigzag in about three weeks after learning that Arc would stop operating on December 22.

The speed of development was not merely the product of a young developer writing quickly.

Arc's shutdown established a clear scope. Existing users already knew what they wanted, so the new project did not need to begin with user research or cover every browser use case.

Zigzag started with macOS. Written in Swift and built on Apple's WebKit, it is positioned as a free, open-source native browser for macOS. It does not wrap Chromium in a thinner interface; it renders pages directly with the system WebView.

This is where it comes closest to Arc: tabs remain at the top instead of moving into a sidebar or sidebar-style workspace. The author explicitly described the familiar top-tab experience as part of the product's positioning in Show HN.

The key here is not reinventing the browser. It is migration.

Users have already adapted to Arc's spatial organization, keyboard shortcuts, and tab layout. A replacement must first reduce switching costs rather than add a collection of unfamiliar buttons.

Zigzag Is Neither Chromium Nor an AI Browser

Browsers generally divide into two technical approaches.

One is based on Chromium. Chrome, Edge, Brave, and Arc all fall into this category, as do many third-party browsers. The other is based on WebKit, with Safari on macOS serving as the best-known example.

Zigao said that the other browsers he had tried were either Chromium forks or included AI. Neither category met his needs, so he built Zigzag with Swift and WebKit.

This explains the project's explicitly anti-AI position.

It does not add a chat sidebar, page summaries, or automated agents. Its selling point is that the page you open is simply the page, rather than turning the browser into a multitool.

The choice is somewhat counterintuitive. Over the past two years, nearly every browser vendor has discussed AI search, page summaries, Copilot features, and agentic browsing. Zigzag instead treats the absence of built-in AI as its differentiator.

The WebKit approach also carries clear tradeoffs.

Browser competition has never been only about rendering speed. Extension ecosystems, account syncing, password management, privacy controls, crash recovery, automatic updates, cross-platform support, and long-term security patches all affect whether users trust a browser with their daily work.

Zigzag has captured Arc's familiar operating habits. Whether its browser infrastructure can support them remains an open question.

Why the Developer Did Not Simply Return to Chrome

After Arc's shutdown, returning to Chrome is indeed the easiest option.

Most accounts, bookmarks, and extensions can be imported, and the interface is familiar. For people who only occasionally use Arc's tab features, the switching cost may not justify changing browsers.

Zigao did not accept that default answer.

According to him, the alternatives he researched or tried fell into two groups: Chromium forks and browsers with AI integration. The first meant continuing to depend on the same engine; the second changed the browser's original boundaries.

Each option crossed one of his two lines of resistance.

The first was Chromium concentration.

Chromium is open source, but its dominance is reflected in the highly concentrated browser market. Web compatibility depends on it, and most major extensions are built around it. Any Chromium-based browser continues to operate within a web platform ecosystem shaped largely by Google.

The second was the intrusion of AI.

Some newer browsers provide AI assistants by default, summarize pages automatically, invoke models, or turn the address bar into a task interface. For people who only want to check documentation, read email, and open background tabs, these features may offer little value while consuming more resources, interrupting normal work, and introducing new privacy concerns.

Zigao's solution was therefore not about stopping Chrome from winning. It was closer to keeping the browser from becoming an entry point for AI.

That positioning has market appeal, but it also has limits.

Being against AI is not the same as being against technology. Users have different answers to whether a browser should include models, especially when they rely on web-based AI, automation extensions, or cross-device syncing. Zigzag chose a narrow, clear path instead of trying to accommodate every preference.

Free and Open Source Helps Migration, but Cannot Replace the Browser Ecosystem

Being free and open source lowers the cost of trying the browser.

Individual users can download it, test the top-tab layout, and check compatibility with their frequently visited sites without submitting a purchase request. With the source code available, the community can also inspect which system capabilities it uses and whether it collects additional data.

For developers, the GitHub repository offers another kind of value.

The combination of Swift and WebKit is straightforward enough to inspect. Developers can read the project structure, build process, and system boundaries rather than waiting for an official team to schedule changes. The repository is now both a runnable sample and a reference for browser interfaces and WebKit integration that others can modify.

Still, moving a browser account is far more complicated than moving bookmarks.

At least four hurdles remain.

  1. Bookmark syncing. Local import is straightforward, but cross-device syncing requires servers, an account system, conflict resolution, and long-term maintenance.
  2. Extension compatibility. Chromium-based extensions may not run directly in a WebKit browser. Their development, debugging, and publishing pipelines may also differ.
  3. Account infrastructure. Password managers, payment confirmations, certificates, and permission management depend on deep cooperation among the browser, applications, and operating system.
  4. Security updates. WebKit will patch its vulnerabilities, but Zigzag still has to manage packaging, upgrade policies, sandbox configuration, crash fixes, and security responses.

Open source solves the problem of making code visible, modifiable, and redistributable. It does not eliminate operational costs.

A project can be completed in three weeks and attract its first users through the open-source community. A browser, however, requires years of continuous maintenance.

That is the clearest divide between free, open-source software and a sustainable product.

Reaching the HN Front Page Does Not Mean the Product Is Mature

Appearing on the Hacker News front page shows that the project reached its target users.

The Show HN thread contains specific problems and people willing to discuss browser design and migration paths. For an individual project, that density of feedback is more useful than download numbers alone.

Front-page exposure and maturity are not the same thing.

Three weeks is both an advantage and a warning.

The advantage is a small codebase and a clear objective, without the burden of technical debt. The risk is that edge cases usually take longer to surface: multiple displays, scaling settings, accessibility tools, input methods, download management, media playback, printing, certificates, private windows, and unusual website dependencies on browser APIs.

Publishing the source also makes problems more transparent. Users can inspect build instructions, issues, and unfinished work directly, and they are unlikely to lower their standards because the project came from a high school student.

Zigzag is better viewed as a successful validation of demand than as a mature successor to Arc.

It demonstrates that Arc's shutdown will not only send users back to Chrome. It can also produce alternatives tailored to specific interaction habits. Top tabs and a native macOS experience are themselves meaningful choices in a market crowded with AI browsers.

Two things will determine what comes next.

First, can it run the sites people use every day reliably? Second, can the project establish a continuous release and security-update process? If it solves only the first, Zigzag will be an excellent personal tool. If it solves both, it could grow from an HN front-page project into a durable browser.

Editorial Assessment

Zigzag deserves attention not because it can already replace Arc, but because it returns browser competition to a concrete question: How far should users have to go to open a web page? Top tabs, keyboard shortcuts, and the WebKit approach are not new features, yet they are enough to attract users who reject Chromium or AI assistants. The project's value lies in validating demand, not proving that its technology stack is superior.

Its anti-AI position may attract the first wave of users, but it is unlikely to become a long-term moat. Extension compatibility, cross-device syncing, and security updates all require sustained investment, while the maintainer must also contend with the limitations of the macOS platform. The established pattern has been for vendors to build a complete browser and then add AI features. Zigzag reverses that order, starting with the migration needs created by Arc's shutdown and retaining only the capabilities its target users clearly want.

That makes it different from browsers that are merely a shell around an existing engine: it addresses a real user problem and includes working code. The available evidence, however, is not enough to confirm long-term maintenance or assess extension compatibility and syncing. Zigzag is best treated as a demand sample rather than a mature replacement for Arc.

Source: https://github.com/ZigaoWang/zigzag