# CEmu: a TI-84 Plus CE emulator built for debugging calculator programs > CEmu is a third-party emulator for the TI-84 Plus CE and TI-83 Premium CE, and its distinguishing feature is the developer toolset: an eZ80 disassembler, memory and register editors, breakpoints, a TI-Basic debugger, and Lua scripting. It needs a ROM dumped from your own calculator and it is not a TI product. **CE-Programming/CEmu** — Third-party TI-84 Plus CE / TI-83 Premium CE emulator, focused on developer features - Repository: https://github.com/CE-Programming/CEmu - Website: https://ce-programming.github.io/CEmu/ - Stars: 1,329 · Forks: 93 - Language: C++ - License: NOASSERTION - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/ce-programming-cemu ## An emulator that assumes you are a developer CEmu is a third-party emulator for the TI-84 Plus CE and the TI-83 Premium CE, and the description says in the same breath that it is focused on developer features. That focus is the whole reason the project exists separately from a general-purpose calculator emulator, and it is visible in the feature list from the first entry. The standard features are the ones you would expect from any competent emulator: accurate and fast emulation with adjustable speed and a throttling toggle, a resizable calculator screen, an always-on-top window option, screen capture and drag and drop as PNG, screen recording as animated PNG, USB emulation for transfers including for apps and operating systems, USB emulation for flash drive images and external devices through libusb, customizable keybindings with multiple presets, keypress recording and history, full screen modes on the F11 key, emulation states for saving and restoring, and CE skins that reproduce the colours of the real devices. The interface is available in English, French, Spanish, Dutch, and Chinese. The project is clear about its status in the market. A note states that CEmu is not a TI product and is not TI-endorsed or affiliated, and that anyone who needs an official TI CE emulator should look at TI-SmartView CE. The homepage is hosted under the CE-Programming GitHub organisation, and the core is written in C with a Qt interface in C++, chosen for performance and portability, running natively on Windows, macOS, and Linux. ## The ROM requirement is deliberate, not an oversight The first standard feature is a built-in ROM dump wizard, and the reason for it is stated plainly: CEmu does not rely on downloading an operating system from TI's website, it has no custom boot loader, and a ROM from your own calculator is required. The wizard exists to make that easy. This is the single most important practical fact about the project, and it separates CEmu from emulators that ship a bootable image. Nothing proprietary is redistributed here, which keeps the project legally clean and is the reason the emulator can exist as free open source software at all. The cost is a one-time setup step where you run the wizard on a physical calculator, transfer the resulting image, and point the emulator at it. The build and release structure reinforces the open source position. The README states that CEmu is licensed under the GPLv3, with the complete licensing information in the LICENSE file, and it lists the parts that come from elsewhere: z80e, Firebird, libtifiles, tivars_lib_cpp, KDMacTouchBar, and FatCow's Farm-Fresh Web Icons, with Lua scripting using Sol2. The repository metadata reports the licence as a custom one that GitHub cannot classify, so the LICENSE file is the text to read. ## The debugger is the reason to switch The developer feature list is long, but it clusters into a handful of areas, and the first is what a programmer actually wants: a debugger. There is code stepping and jumping, read, write, and execute breakpoints, watchpoints, an eZ80 disassembler with support for equates, and a port monitor and editor, a general timer monitor and editor, a memory viewer and editor, a CPU state and registers viewer and editor, and an LCD state and parameters viewer and editor. The second cluster is about understanding the machine as a system rather than a program. Advanced LCD parameter emulation covers gamma and response time, there is tracking of flash cache misses and average access time, a memory visualizer that renders fully customisable virtual LCDs, a stack viewer, an OP1-7 viewer, FP and OP stack viewers and editors, a Variable Allocation Table viewer, a variable list with preview and program launcher, a TI-Basic program viewer with syntax highlighting and reformatting, and a TI-Basic program debugger with line-by-line stepping. The third cluster is about making the emulator scriptable, which is where it stops being a toy. There is a rich text console for logging and debugging, a cycle counter for benchmarking and profiling, emulation of DMA and SPI for accuracy, miscellaneous emulation such as backlight and battery, an autotester described as automated unit testing with light scripting, and Lua scripting with a script manager, autoload and CLI support, events, conditional breakpoints, zdis bindings, and deterministic input and TAS helpers. The deterministic input helper deserves attention. Being able to replay a fixed sequence of inputs turns an emulator into a reproducible test environment, which is the closest thing here to CI for calculator programs. ## Reproducibility, state snapshots, and scriptable runs Several features exist for the same underlying reason, which is that a developer wants the same result twice. Emulation states allow saving and restoring, so a session can be captured at a known point and resumed. The cycle counter gives a measurement independent of wall clock time, so a performance comparison between two builds of a program is meaningful rather than a matter of how busy the machine was. The hardware revision option sits in the same family. CEmu lets you choose the ASIC or hardware revision to emulate, with A, pre-I, and M+ named as options, and it emulates DMA and SPI for optimal accuracy. Real CE calculators shipped with several different hardware revisions, and code that works on one can misbehave on another because of timing and peripheral differences. A revision switch is what lets you test that case on one machine. The custom display refresh rate and the FPS indicator complete the picture. A program that draws at a fixed rate will behave differently on a display with a different refresh, and being able to change the refresh rate in the emulator is how you find out whether a rendering routine depends on the hardware timing rather than on a frame counter. The port and timer editors belong here too, though they point the other way. They let you change the state of a hardware port or timer, which is how you reach a code path that would otherwise take a specific button press at a specific moment. ## Running it and building it Installation is a download rather than a build. Official stable releases are published on the GitHub releases page, and development builds are available from an auto-updating nightly pre-release. One detail matters: release builds have an update checking feature, which is disabled in development builds, so if you want to avoid the app phoning home, use a development build. On first run there is a sequence worth knowing. The ROM dump wizard is the first thing to do, since nothing runs without a ROM image from your own calculator. After that the ordinary developer features are available from the interface, and the main options are also reachable through command line arguments, which is what makes scripted and headless runs possible. Several CEmu processes can be launched together with IPC features between them, so one process can drive another, for example to script a scenario in one window while the debugger watches it. Building from source is documented on the project wiki page titled Building CEmu, and the repository ships CI workflows for Windows, macOS, and Linux with badges for each. The source layout mirrors the architecture: a core/ directory for the emulator in C, a gui/ directory for the Qt interface, obs/ for observations, scripts/, tests/, and docs/. There is a.gitmodules file, so some dependencies arrive as submodules rather than being vendored. Contributors are asked to format code with Artistic Style using the settings in the.astylerc file, and Qt Creator can be configured to run it, and translations are welcome, with Qt Linguist named as the tool. ## Against TI-SmartView CE and against writing tests blind The alternative the project itself points to is TI-SmartView CE, the official TI emulator. The difference in approach is ownership of the machine image and the target audience. TI-SmartView CE is the official TI emulator the project points to. CEmu is a GPLv3 project that refuses to ship a TI operating system image, requires you to dump the ROM from your own device, and then adds a debugger, disassembler, state editors, and scripting on top of it. If your goal is to run a program, the official emulator is the simpler answer. If your goal is to find out why a program is wrong, the official emulator is not a development environment at all. The second alternative is what most CE developers did before this project existed, which is to test on hardware. Push the program to the calculator with a tool such as a shell, run it, and watch the screen. The difference in approach is feedback speed and observability. On hardware you see the screen and nothing else, so a fault that corrupts memory or a timer register leaves no visible trace unless it crashes. In CEmu the same run can be stepped through in the TI-Basic debugger line by line, the CPU state and registers can be inspected and edited, the VAT and the variable list can be read, and a breakpoint can be placed on a write to a specific address. There is a real cost to the emulator route, and it is worth stating: a calculator program can behave differently on hardware than in the emulator, precisely because the emulator models the hardware rather than being it. Timing quirks, and anything touching the USB stack or the flash write path, are where the two can diverge. The accuracy work in CEmu, with DMA and SPI emulation and the hardware revision option, exists to close that gap, and it is why the revision choice matters. ## The release history is uneven, and nightlies are the real product The published versions tell you where to look for stability. v2.0, described as major core and GUI improvements plus new features, was published on 2024-09-05. Before that v1.3 came out on 2019-06-22, and the nightly pre-release, which carries auto-updating binaries, dates from 2023-01-13. The last push to the repository was on 2026-10-14, so the working tree is being worked on steadily even though the tagged stable release is not recent. That split is the thing to plan around. The stable channel is old enough that the Lua scripting feature described in the documentation may or may not be in it, and the nightly channel is where current work lands. The release builds have update checking and the development builds do not, so a developer who wants the current code and the current feature set should take the nightly, and a developer who prefers a tagged release should accept the older feature set. Help is organised around a Discord server, with the cemu-emulator channel, and an IRC bridge to the EFNet cemu-dev channel that can be used from a web client. The README is candid about the response rate, noting that the answer depends on how active the channel is and that issues are the fallback. The project is community-run and the ask is concrete: report bugs, request features, or send patches, and join the CE Programming Discord if you want to ask a question. ## Conclusion Adopt CEmu if you write TI-Basic or assembly for the CE and need a debugger, a disassembler, and scriptable automation, and if you are willing to dump a ROM from your own calculator. Do not adopt it as a general calculator emulator for casual use, since the ROM requirement and the developer focus both point the other way. Verify first that your build of the emulator matches the hardware revision you are targeting, because the ASIC revision option changes what the emulated machine looks like. ## FAQ ### Why does CEmu need a ROM from my own calculator? CEmu does not rely on downloading an operating system from TI's website and has no custom boot loader, so a ROM from your own calculator is required. A built-in ROM dump wizard makes obtaining that image straightforward. ### What debugger features does CEmu provide for TI-Basic programs? There is a TI-Basic program debugger with line-by-line stepping, along with code stepping and jumping, read, write and execute breakpoints, watchpoints, and an eZ80 disassembler with equates support. Memory, register, stack, VAT, and LCD state viewers and editors are also listed among the developer features. ### Can I script CEmu? Yes. Lua scripting is supported with a script manager, autoload and CLI support, events, conditional breakpoints, zdis bindings, and deterministic input and TAS helpers, and Sol2 is used as the binding library. There is also an autotester for automated unit testing with light scripting, and the main options are available through command line arguments. ### What licence is CEmu released under? The README states that CEmu is licensed under the GPLv3, with the complete licensing information in the LICENSE file. Parts of the project are derived from or inspired by z80e, Firebird, libtifiles, tivars_lib_cpp, KDMacTouchBar, and the Farm-Fresh Web Icons. ### Where do I get stable and development builds of CEmu? Official stable releases are on the GitHub releases page, and development builds are available on the auto-updating nightly pre-release. Release builds include an update checking feature that is disabled in development builds. ## Sources - [CE-Programming/CEmu on GitHub](https://github.com/CE-Programming/CEmu) - [Issues](https://github.com/CE-Programming/CEmu/issues) - [Project website](https://ce-programming.github.io/CEmu/) - [README](https://github.com/CE-Programming/CEmu/blob/master/README.md) - [Releases](https://github.com/CE-Programming/CEmu/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ce-programming-cemu