Stack

Swift + SwiftUI

Toolchain

Xcode project (synchronized groups) · xcodebuild · Simulator or device

Interact

Runs in the iOS Simulator or on a paired device. TransistorBridge streams live screenshots and logs and reports the current screen; on the Simulator TransistorKit can inject taps and drive navigation.

Stack

Swift + SwiftUI (focus engine)

Toolchain

Xcode tvOS target · xcodebuild · Apple TV Simulator

Interact

Runs in the tvOS Simulator. The bridge reports the focused screen and captures the TV frame; TransistorKit drives the Siri Remote — directional focus moves and select.

Input injection needs macOS Accessibility (TCC) permission.

Stack

Swift + SwiftUI / AppKit

Toolchain

Xcode macOS app · xcodebuild · runs natively on your Mac

Interact

Launches natively on the Mac. TransistorKit captures the app window by window ID and tails live logs; synthetic events can drive it where macOS TCC permission allows.

Stack

Kotlin + Jetpack Compose

Toolchain

Gradle project · emulator or adb-connected device

Interact

Installs to an emulator or a physical device over adb. TransistorBridge streams frames and Logcat lines; TransistorKit injects taps and keys via adb. Physical devices need one `adb reverse tcp:<port> tcp:<port>` to reach the bridge.

Stack

Kotlin + Compose for TV

Toolchain

Gradle TV module (com.emtanonapps.transistorkittv) · Android TV emulator / Fire TV (minSdk ≤ 30)

Interact

Deploys to an Android TV emulator or a Fire TV stick over adb. TransistorKit drives the D-pad and select and captures the TV frame; logs stream through the same bridge.

Input is driven through DOM events / a headless driver rather than the OS.

Stack

TypeScript · modern ESM (Vite SPA or Astro site)

Toolchain

npm + Vite / Astro · runs in the browser or as a static bundle

Interact

Serves locally in the browser. The JavaScript bridge posts page-view and per-screen beacons and can capture the DOM/canvas, so TransistorKit sees exactly what's on the page as you use it.

Headless service — observed by log stream and HTTP probes.

Stack

Node.js REST / API service

Toolchain

npm · runs as a process · deploy over SSH

Interact

Runs as a local or remote process. TransistorKit tails structured logs and probes endpoints; being headless, its “screenshot” is a request/response probe rather than a picture.

Logs come from the emulator trace; input is emulated controller state.

Stack

6502 assembly / C (cc65)

Toolchain

cc65 / ca65 toolchain → .nes ROM · bundled NES emulator

Interact

Assembles a ROM that runs in the bundled NES emulator. TransistorKit grabs the framebuffer and injects controller state; the app's nametable, tile-set and sprite editors feed straight into the build.

Logs and input are provided by the emulator.

Stack

C (GBDK) / RGBDS assembly

Toolchain

GBDK / RGBDS → .gb ROM · Game Boy emulator

Interact

Builds a .gb ROM that runs in the emulator. TransistorKit captures the 160×144 frame and injects the D-pad and A/B buttons.

Logs and input are provided by the emulator.

Stack

C (GBDK, CGB features)

Toolchain

GBDK → .gbc ROM · Game Boy Color emulator

Interact

Same pipeline as the Game Boy with color palettes. The emulated frame is captured and buttons are injected by TransistorKit.

Logs and input are provided by the emulator.

Stack

C (SGDK, Motorola 68000)

Toolchain

SGDK → .bin / .md ROM · Genesis emulator

Interact

Compiles a Genesis ROM that runs in the emulator. TransistorKit captures the frame and injects 3-/6-button pad input.

Logs and input are provided by the emulator.

Stack

Z80 assembly / C (devkitSMS)

Toolchain

devkitSMS → .sms ROM · Master System emulator

Interact

Builds an .sms ROM that runs in the emulator. TransistorKit grabs the frame and injects pad input.

Screenshot only when the board drives a display; physical inputs aren't injectable.

Stack

C++ (Arduino framework / ESP-IDF)

Toolchain

arduino-cli / PlatformIO · flashed over USB serial (Wi-Fi + BLE capable)

Interact

Flashed onto the ESP32 over serial. TransistorKit reads the serial log stream and, because the chip is networked, a Wi-Fi heartbeat can report live presence; boards driving a display can have their framebuffer captured.

Serial-only board — observed through the serial monitor.

Stack

C++ (Arduino / AVR)

Toolchain

arduino-cli / avr-gcc · flashed to the ATmega328P over USB serial

Interact

Flashed over USB serial. TransistorKit tails the serial monitor for logs and a serial heartbeat; with no display or radio, presence is serial-based and there's no visual capture.

Screenshot only with an attached display; inputs aren't injectable.

Stack

C / C++ (Pico SDK) or MicroPython

Toolchain

Pico SDK / CMake → UF2 · flashed over USB (BOOTSEL mass-storage)

Interact

Builds a UF2 that's copied onto the RP2040's mass-storage. TransistorKit reads USB-serial (stdio) logs; boards with an attached display can be frame-captured.

Screenshot only for designs that output video; no input injection.

Stack

Verilog / SystemVerilog (Gowin)

Toolchain

Gowin / Yosys + nextpnr → bitstream · programmed to the FPGA

Interact

Synthesizes a bitstream and programs the Tang Nano. TransistorKit reads UART output for logs and presence; designs that drive HDMI/video can be frame-captured.

“Screenshot” is a terminal-output snapshot; input is piped through stdin.

Stack

Swift / TypeScript / Python (your pick)

Toolchain

SwiftPM / npm / PyInstaller · runs in the terminal

Interact

Runs as a terminal process. TransistorKit captures stdout/stderr as logs and a terminal transcript, and can feed stdin — so its “screenshot” is a snapshot of the terminal output.