Open-source project
TomHarte/CLK avatar
TomHarte/CLK

clk lets your GPU decode composite video and never takes your files

A latency-hating emulator of: the Acorn Electron, BBC Micro and Archimedes, Amstrad CPC, Apple II/II+/IIe and early Macintosh, Atari 2600 and ST, ColecoVision, Enterprise 64/128, Commodore Vic-20 and Amiga, MSX 1/2, Oric 1/Atmos, early PC compatibles, Sega Master System, Sinclair ZX80/81 and ZX Spectrum, Tandy CoCo and Thomson MO5/6.

1,154 stars72 forksC++MIT

At a glance

What is it?
An emulator covering twenty-two eight-bit and early home computers, built around two ideas: the emulated machine emits the signal the real hardware emitted, so composite artifacts appear because they are computed rather than filtered, and loading is two clicks because the machine and its boot command are inferred from the media. The page also says it attempts cycle accuracy on every supported machine, and then qualifies that.
Who is it for?
clk is a good fit if you keep your software where your operating system already launches things, because the whole design assumes you should not have to learn the machine it emulates. Three things to check.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • TomHarte/CLK1,154 ★ · +25
Star history
Repository2026-07-282026-11-15
TomHarte/CLK1.1k1.2k

25 Stars in the last 110 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Composite artifacts are computed, not painted on

The signal processing section is the most interesting paragraph in the page, and it is an argument rather than a feature list.

The chain of reasoning starts with an ordinary, unmodified Commodore Vic-20. Its only video output is composite. Therefore the emulated machine's only video output is composite. To display it, the host GPU has to decode composite video. Therefore the composite artifacts you see are present and correct, and the page is explicit that they are not the result of a post hoc filter, because the real signal is really being processed.

That decision has a consequence worth naming. The emulator's output quality now depends on a decode step it delegates to the host, so two machines running the same build may show the same artifact differently. That is the trade the project is making: real artifacts that are host-dependent, instead of a guaranteed-approximate look that is not.

Audio follows the same rule. If the real machine generates audio at 192 kHz, the emulator generates a 192 kHz source signal and filters it down to whatever the host can output. The filtering is the part that adapts to the host; the source rate is not a preference.

The screenshot tables on the page are arranged around this distinction, comparing a plain pixel copy against a decoded composite and against a filtered but correctly proportioned image.

Loading is two clicks because the machine is chosen for you

The single-step loading section describes a mechanism rather than a user interface.

Through static and runtime analysis, the emulator seeks to select and configure the appropriate machine for any provided disk, tape or ROM, to issue whatever commands are needed to run the software on it, and to provide accelerated loading where feasible. Three jobs, and the third is explicitly conditional.

The user-visible result is stated as a two-step process. Locate the file in your operating system. Double click it. There is no step for creating a machine, inserting media into it, or working out which load command belongs to that piece of software.

What is more unusual is what the emulator refuses to do. The page says there is no import procedure, and that it does not attempt to take ownership of your files or to usurp your operating system. The consequence is an instruction about where your files should live: on your desktop, in your dock, or wherever you normally launch software from, the way you would launch anything else.

That constraint is what makes the feature work. A single-click load has to be implemented by the host launching the file, so the emulator is a handler rather than a library, and the analysis of the media happens after launch.

Cycle accurate on everything, and in some cases it succeeds

The accuracy section is short, and its framing is unusual for an emulator.

Accuracy is presented as a user-experience issue rather than an engineering virtue: the more accurate an emulator, the more likely a user can run every piece of software they are interested in without further intervention. The stated goal follows from that, namely to attempt cycle-accurate emulation of all supported machines.

Then the final sentence: in some cases it succeeds.

That is an unusually blunt place to stop, and it does more work than a hedge. Cycle accuracy is expensive to reach and expensive to verify, and a project spanning twenty-two platforms is not going to get there uniformly. Stating it this way converts accuracy from a promise into a probability, and the user-experience framing gives it a reason: the parts that need intervention are the parts users notice.

The repository also does not pretend the platform list is uniform. Nineteen systems are listed as emulations, and three more are described as present but less rounded, with those three named separately in a second list rather than folded into the first.

Twenty-two machines in two tiers, flattened in the repository summary

The machine list is worth reading in two parts, because the tiers carry information the count does not.

The rounded list has nineteen entries: the Acorn Electron, the Amstrad CPC, the Apple II in three variants, the Atari 2600 and ST, the BBC Micro, the ColecoVision, the Commodore Plus 4 and Vic-20, the Enterprise 64 and 128, four early Macintosh models, MSX 1 and 2, the Oric, the Sega Master System, the Sinclair ZX80 and 81, the Sinclair ZX Spectrum, the Tandy CoCo, and the Thomson MO5 and 6.

The second list has three: the Acorn Archimedes, the Commodore Amiga, and early PC compatible machines. Those are described as present but less rounded, which in emulator terms usually means a subset of the hardware works and the rest does not.

Now compare that with the repository's one-line summary, which lists the same twenty-two systems in a single comma-separated run with no tiering at all. Someone reading the summary would reasonably assume parity, and the Amiga in particular is a machine where partial emulation is a familiar disappointment.

So the honest version of the compatibility claim lives in the README's second list, not in the metadata, and it is worth checking before you rely on a particular machine.

Video throughput is claimed and audio latency is measured

The low-latency section is short and mostly hands the decision to your hardware.

The display is an emulated cathode ray tube with phosphor decay. That means a 140 hertz 4k monitor can produce 140 distinct frames per second at 4k resolution, because the emulated machine is not tied to a 60 hertz refresh the way the original hardware was.

Then the sentence that defines the whole section: latency is dictated by the host hardware, not the emulated machine or the emulator. No frame-latency figure is offered, and none is claimed.

Audio is the one place with a number. Audio latency is disjoint from frame rate and is generally restrained to between five and ten milliseconds. So the only latency figure on the page is for the path where the host cannot decouple the two, which is also the path where a perceivable delay is most likely to be attributed to the emulator.

Together with the signal processing section, the position is coherent: generate at the rate the original hardware used, let the host decimate what it cannot output, and do not promise a response time the host does not control.

One native Mac app and two possible Linux front ends

The platform story is short enough to state precisely, and it has one asymmetry.

On the Mac it is a native application using the system UI framework and Metal for graphics. Under Linux, BSD and other UNIX systems and lookalikes it uses OpenGL instead, and can be built against either of two interface toolkits.

So there are three rendering paths across two operating systems, and two toolkit choices within the UNIX path. That is a normal consequence of supporting a native-first platform alongside a portable one, but it does mean the UNIX build is a choice rather than a default.

The packaging reflects only part of that. macOS binaries and source releases are hosted on the project's GitHub releases, while the Linux distribution channel is a Snap, and the Snap is described as the Qt-based build. So the one-click Linux install is one of the two available Linux front ends, not a build of both.

The repository layout matches the platform-agnostic ambition. A top-level build file, a build document, a dedicated module directory, and a long list of directories named after concerns rather than machines, which is what lets the same codebase hold emulations for machines with almost nothing in common.

The tree is organised by concern and carries no test directory

The top-level entries describe an architecture rather than a set of machines, and that is the single most useful thing to know before reading any of the code.

The concern-named directories cover audio generation, video generation, timing, execution, parallel work, configuration, inputs, outputs, processor instruction sets, numeric types, host integration, processors, storage, the per-machine implementations themselves, packaging and shared components. There is also a directory named for the receiver in a radio sense, and one named for a kind of computer peripheral, and one for reading machine descriptions.

That structure is what makes the two-tier machine list credible as a claim. A new platform is a machine directory plus wiring into the shared components, not a new application, and the absence of any per-platform top-level directory is the evidence.

The gap in the listing is a test directory. There is nothing at the top level that holds tests, in a project whose stated goal includes cycle-accurate emulation of twenty-two machines. Whether verification happens elsewhere, inside the machine directories, is not answered by the tree.

Releases, meanwhile, are tagged by date rather than by version, which is a common choice for an emulator with no API to preserve and a real cost for anyone pinning a build.

Editorial conclusion

clk is a good fit if you keep your software where your operating system already launches things, because the whole design assumes you should not have to learn the machine it emulates. Three things to check. The composite path depends on your graphics stack doing the decoding, which is the honest cost of fidelity and also means output can vary with the host. The machine coverage is deliberately uneven, with three systems named as present but less rounded, so check that your title's platform is on the rounded list. And the accuracy claim is qualified on the page itself, which is a reasonable thing for an emulator to say and a useful reminder that software compatibility is empirical rather than guaranteed. Releases are tagged by date, so there is no version to pin.

Frequently asked questions

Which machines does the clk emulator cover?

Nineteen systems are listed as emulations, including the Acorn Electron, Amstrad CPC, Apple II family, Atari 2600 and ST, BBC Micro, ColecoVision, Commodore Plus 4 and Vic-20, Enterprise 64 and 128, four early Macintosh models, MSX 1 and 2, Oric, Sega Master System, Sinclair ZX80 and 81, ZX Spectrum, Tandy CoCo and Thomson MO5 and 6. The Acorn Archimedes, Commodore Amiga and early PC compatibles are listed separately as present but less rounded.

Do I need to configure a machine before loading software in clk?

No. Through static and runtime analysis the emulator selects and configures the appropriate machine, issues the commands needed to run the software, and provides accelerated loading where feasible. The documented process is to locate the file in your operating system and double click it, with no import procedure, and the emulator does not take ownership of your files.

How does clk reproduce composite video artifacts?

By emitting the signal the real machine emitted. A machine whose only video output is composite produces composite output, the host GPU decodes it, and the artifacts appear because the signal is genuinely processed rather than filtered afterwards. Audio follows the same rule: a machine that generates audio at 192 kHz produces a 192 kHz source signal that is filtered down to what the host can output.

What is the latency of the clk emulator?

Latency is dictated by host hardware rather than by the emulated machine or the emulator, and the page gives no frame-latency figure. Because the display is an emulated CRT with phosphor decay, a 140 Hz 4k monitor can produce 140 distinct frames per second at 4k. Audio latency is disjoint from frame rate and is generally restrained to between 5 and 10 milliseconds.

How is the clk emulator distributed?

macOS builds and source releases are hosted on the project's GitHub releases, and a Qt-based Linux build is available as a Snap. The Mac application is native and uses Metal for graphics, while under Linux, BSD and other UNIX systems it uses OpenGL and can be built with either Qt or SDL. Releases are tagged by date rather than by version.

Official sources

  1. Official README
  2. Project repository
  3. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tomharte-clk.svg)](https://hysenlabs.com/projects/tomharte-clk)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tomharte-clk.svg)](https://hysenlabs.com/projects/tomharte-clk)

Was this useful?