awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
nesbox avatar

nesbox/TIC-80

0
View on GitHub↗
5,825 stars·584 forks·C·mit·23 viewstic80.com↗

TIC 80

TIC-80 is a fantasy console platform and multi-language game engine that provides a virtual retro game development environment. It operates via a bytecode virtual machine that executes game logic within fixed memory and resolution constraints.

The project distinguishes itself by offering integrated asset editors for pixel art, tile maps, and a pattern-based chiptune audio workstation all within a single environment. It supports multi-language scripting, allowing developers to write logic in Lua, JavaScript, or Ruby, and provides a standalone game exporter to package projects into native executables for Windows, Linux, macOS, and Raspberry Pi.

The platform covers a broad range of capabilities, including 2D and textured triangle rendering, raw RAM access with bank-switched memory management, and comprehensive input processing for keyboards, mice, and gamepads. It also includes a virtual filesystem for project organization and a scanline interrupt system for creating raster effects.

Features

  • Fantasy Consoles - Implements a virtual retro console environment with fixed resolution, color palette, and memory constraints.
  • Fantasy Consoles - Operates as a complete fantasy console platform with integrated asset editors and a bytecode virtual machine.
  • Bytecode Virtual Machines - Provides a bytecode virtual machine that emulates a retro console with fixed memory and display constraints.
  • Multi-Language Script Execution - Supports the execution of game logic written in multiple scripting languages including Lua, JavaScript, and Ruby.
  • Integrated Asset Editors - Ships an integrated suite of editors for creating pixel art, tile maps, and chiptune audio.
  • Animated Tilemap Rendering - Pico-8 draws a rectangular region of the map to the screen with sprite animation callbacks.
  • Chiptune Audio Production - Provides an integrated pattern-based audio workstation for composing chiptune music and sound effects.
  • Game Logic Scripting - Supports writing game logic using a unified API across Lua, JavaScript, and Ruby.
  • Real-time Input Processing - Pico-8 detects state changes for gamepads, keyboards, and mouse movements to drive real-time interactivity.
  • Retro Game Engines - Offers a complete engine for creating games with vintage aesthetics and constrained technical specifications.
  • Chiptune Trackers - Includes an integrated pattern-based chiptune audio workstation for composing music and sound effects.
  • Pixel Art Editors - Includes built-in editors for designing pixel-perfect sprite sheets and grid-based world maps.
  • Direct Memory Access - Implements low-level raw memory access via peek and poke operations to manage the virtual machine's memory space.
  • Fixed-Timestep Loops - Executes game logic at a constant, fixed frame rate to ensure consistent simulation speed across different hardware.
  • Volatile Register Access - Provides access to memory-mapped system registers for low-level hardware interaction within the virtual console.
  • Virtualized Filesystem Layers - Implements a virtual filesystem to organize and manage project files within the sandboxed environment.
  • Debugging Consoles - Includes an embedded console for printing debug messages to track execution flow and variable states.
  • Execution Environment Controllers - Ships an execution environment controller for managing debug logging, session resets, and exiting to the system prompt.
  • Standalone Binary Packaging - Packages the virtual machine and game assets into native standalone executables for multiple platforms.
  • Cross-Platform Execution - Ensures that packaged game files can be executed across multiple operating systems and devices.
  • Cross-Platform Game Compilation - Provides a pipeline to build native binaries for Windows, Linux, macOS, and Raspberry Pi from a single project.
  • 2D Primitive Rendering - Draws basic geometric shapes and text to a fixed-resolution screen.
  • Audio Playback - Provides controls for playing back sound effects and music with adjustable pitch, volume, and looping.
  • In-Engine Track Streaming - Streams pre-composed music tracks with integrated controls for tempo and looping.
  • Dynamic Pixel Renderers - Programmatically calculates and draws shapes, sprites, and maps on a pixel display.
  • Shape Rendering - Renders filled or outlined circles, rectangles, triangles, and lines.
  • Sprite Manipulation Tools - Supports placing, scaling, flipping, and rotating individual or composite sprites on screen.
  • Sprite State Managers - Provides built-in state storage by attaching eight boolean flags to each sprite for game metadata.
  • Boolean State Flags - Allows developers to set and read boolean flags on sprites to manage game-specific object states.
  • Tile Map Renderers - Renders grid-based map sections to the screen with support for real-time tile replacement.
  • Tilemap Data Modification - Allows getting and setting sprite identifiers at specific map coordinates to modify game worlds.
  • Scanline Interrupts - Enables raster effects by executing custom logic during the vertical blanking interval.
  • Interactive Sound Effect Managers - Triggers specific sound identifiers across multiple channels to provide interactive audio feedback.
  • Textured Mesh Rendering - Fills triangles using textures sampled from image RAM to simulate 3D graphics.
  • Memory Banking Implementation - Implements a bank-switching memory model to manage RAM and persistence within the virtual console.
  • Persistent Memory Banks - Saves and loads runtime memory to persistent banks for game progress and save-state features.
  • Stateful Bank Synchronization - Synchronizes runtime memory to specific banks to manage stateful game progression.
  • Bytecode Compilation - Compiles multiple scripting languages into a unified bytecode format for execution on the virtual machine.
  • Bit Manipulation Techniques - Provides the ability to manipulate individual bits and bytes in RAM to modify sprites, maps, and sounds.
  • Double-Buffered Rendering - Utilizes double-buffered rendering with dual VRAM banks to eliminate screen flicker.
  • Bitmap Font Rendering - Renders text strings by mapping characters to custom fonts defined within the sprite set.
  • Sprite & Particle Rendering - Displays tiles from sprite sheets with support for scaling, flipping, and rotation.

Star history

Star history chart for nesbox/tic-80Star history chart for nesbox/tic-80

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with TIC 80

These projects share indexed features with TIC 80. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • id-software/quakeid-Software avatar

    id-Software/Quake

    5,659View on GitHub↗

    This is the original C source code for the Quake game engine, a landmark first-person shooter engine from the 1990s. It is a retro game engine that renders 3D environments and processes player input in real time using CPU-based software rendering rather than GPU acceleration. The engine supports networked multiplayer gameplay over LAN or internet connections and is designed to be moddable, allowing users to create and run custom game modifications and levels. The engine's architecture includes a Binary Space Partition tree for efficient world geometry organization and visibility determination

    C
    View on GitHub↗5,659
  • yuin/gopher-luayuin avatar

    yuin/gopher-lua

    6,933View on GitHub↗

    Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It serves as an embedded scripting engine and virtual machine that allows Go applications to execute Lua scripts and exchange data between the host and the script environment. The project provides a bytecode compiler to transform source code into a binary format for faster execution. It enables deep integration between the two languages by allowing the registration of native Go functions to be called from scripts, and the invocation of script functions directly from Go. The engine c

    Gogogopher-lualua
    View on GitHub↗6,933
  • godotengine/godot-demo-projectsgodotengine avatar

    godotengine/godot-demo-projects

    8,250View on GitHub↗

    This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

    GDScript
    View on GitHub↗8,250
  • hzeller/rpi-rgb-led-matrixhzeller avatar

    hzeller/rpi-rgb-led-matrix

    4,312View on GitHub↗

    This project is a C++ library and hardware driver designed to control Hub75 RGB LED panels using the GPIO pins of a Raspberry Pi. It functions as both a low-level panel controller and a graphics library for rendering visual content on low-resolution LED grids. The system distinguishes itself through a comprehensive set of hardware configuration tools, including custom pixel mapping, rotation, and mirroring to match physical display geometries. It supports multi-display chaining in both parallel and series configurations and provides a Python binding to expose the core C++ logic for hardware a

    C++gpioled-panelsmultiplexing
    View on GitHub↗4,312
Compare all 30 related projects→

Frequently asked questions

What does nesbox/tic-80 do?

TIC-80 is a fantasy console platform and multi-language game engine that provides a virtual retro game development environment. It operates via a bytecode virtual machine that executes game logic within fixed memory and resolution constraints.

What are the main features of nesbox/tic-80?

The main features of nesbox/tic-80 are: Fantasy Consoles, Bytecode Virtual Machines, Multi-Language Script Execution, Integrated Asset Editors, Animated Tilemap Rendering, Chiptune Audio Production, Game Logic Scripting, Real-time Input Processing.

Which projects share features with nesbox/tic-80?

Projects with overlapping indexed features include: id-software/quake — This is the original C source code for the Quake game engine, a landmark first-person shooter engine from the 1990s.… yuin/gopher-lua — Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It… godotengine/godot-demo-projects — This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the… hzeller/rpi-rgb-led-matrix — This project is a C++ library and hardware driver designed to control Hub75 RGB LED panels using the GPIO pins of a… luau-lang/luau — Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an… tencent/puerts — Puerts is a TypeScript runtime embedder and game engine scripting framework designed to integrate dynamic languages…