Projects sharing features with TIC 80

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

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

Puerts is a TypeScript runtime embedder and game engine scripting framework designed to integrate dynamic languages into low-level host applications. It functions as a high-performance cross-language API bridge, allowing developers to execute gameplay logic and editor scripts using TypeScript and JavaScript within a compiled host environment. The project distinguishes itself through a unified bridging API that supports pluggable scripting backends, enabling the selection or hot-swapping of different language engines to balance execution speed against binary size. It provides automated type de

Urho3D is a cross-platform 3D game engine written in C++. It uses a component-based scene graph to compose game objects from nodes and attached components, separating transforms from behaviors for modular design. The engine integrates AngelScript and Lua scripting for game logic, uses the Bullet library for physics simulation, and renders scenes with OpenGL or Direct3D through forward, deferred, or light pre-pass pipelines with customizable render passes and shadow mapping. The engine distinguishes itself with a built-in visual scene and UI editor for composing 3D worlds and interface layouts

Spring is a cross-platform game engine and framework designed specifically for the development and execution of multiplayer real-time strategy games. It provides a high-performance simulation environment for managing large-scale battles and unit movements across different operating systems using a shared codebase. The engine functions as a multiplayer game server and networking layer, coordinating real-time game state and match synchronization between remote players. It includes a dedicated lobby client system for multiplayer match coordination as well as the capability to execute single-play

jynew is a 3D RPG game engine and development framework designed for building three-dimensional role playing games. It provides a comprehensive suite of tools for scene editing, game logic scripting, and the creation of 3D environments. The project features a specialized 3D asset management pipeline for importing and aligning models and animations, including specific tools for weapon attachment and rendering. It includes a dedicated combat system editor for defining battle encounters, skill effects, and combat grids with real-time synchronization. Additionally, it provides a game modding fram

Pyxel is a Python-based retro game engine designed for creating pixel-art applications with vintage aesthetics. It functions as a pixel art framework that emulates classic hardware limitations through fixed-resolution displays, constrained color palettes, and a 2D tilemap engine for rendering scaled sprites and grid-based game worlds. The engine features a dedicated MML audio synthesizer that uses Macro Language notation to compose and play back retro-style sound sequences. It also includes capabilities for seed-based background music generation and the playback of raw PCM audio data for cust

tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res

This project is a cross-platform game engine framework and build pipeline designed to produce playable executable binaries for desktop and Android devices. It provides a collection of core libraries for game development, including a native Android build system and a C++ build pipeline. The framework features a specialized bitmap font rendering system that displays stylized typography by mapping character indices to image atlases using coordinate and spacing metadata. It also implements a hardware abstraction layer to decouple application logic from graphics and audio drivers, ensuring portabl

mGBA is a high-accuracy Game Boy Advance emulator and hardware-level debugger designed to run handheld console ROMs on modern computers. It serves as a scriptable emulation environment that allows for the execution of portable hardware software and the simulation of associated peripherals. The project distinguishes itself through its focus on technical analysis, providing a suite of tools for retro game debugging and game logic inspection. It includes a host-client debug protocol that enables external debugger connectivity via TCP socket communication and an event-driven scripting engine for

This project provides a full Python interpreter compiled to WebAssembly, enabling the execution of Python code and scientific libraries directly within web browsers and server-side environments. By bridging the gap between language runtimes, it allows developers to run computational tasks, manage packages, and perform data analysis in client-side environments without requiring a backend server. The platform distinguishes itself through a comprehensive foreign function interface that enables bidirectional data exchange, object proxying, and function calling between Python and JavaScript. It in

LittleJS is a lightweight HTML5 2D game engine designed for building web games using Canvas and WebGL without external dependencies. It integrates a WebGL sprite renderer, a 2D physics engine for arcade-style collisions and rigid-body dynamics, and a grid-based A* pathfinding system for entity navigation. The engine is distinguished by its procedural audio synthesizer, which generates music and sound effects at runtime using parameter arrays to minimize file sizes. It also features a comprehensive graphics pipeline that supports custom fragment-shader post-processing and a dynamic 2D lighting

SoundManager2 is a JavaScript audio API and cross-browser audio engine designed to provide consistent playback across different web browsers and devices. It functions as an HTML5 audio wrapper and playback manager that abstracts native APIs into a unified interface, ensuring compatibility through an automatic switching mechanism between available audio backends and codecs. The library distinguishes itself with an RTMP audio streamer for network communication with media servers and a built-in ID3 metadata parser for extracting track titles, artist information, and genre tags from audio files.

Shumway is a browser-based Flash emulation system designed to execute Shockwave Flash content without the need for native plugins. It focuses on the preservation of legacy Flash content by rendering SWF files within modern web browsers. The project utilizes a JavaScript-based virtual machine to parse and execute SWF bytecode, recreating the original program logic. This environment simulates a CPU and memory layout to enable the display and playback of interactive animations and applications. The system manages a software-based rendering pipeline that draws vector shapes and bitmaps onto a ca

This project provides a server-side language runtime and a standardized Docker image for deploying applications across different operating systems. It functions as an execution environment for generating dynamic HTML, JSON, and XML content, while also serving as a command line interface for automation scripts and background jobs. The runtime is designed for extensibility through a C-based extension architecture, allowing the loading of custom modules for specialized functionality. It supports multiple server application interfaces, including a FastCGI web interface for high-performance commun

PixiEditor is a multi-functional graphics suite that serves as a pixel art editor, a node-based graphics editor, and a vector graphics tool. It functions as a shader-based painting tool and 2D animation software, providing a comprehensive environment for creating raster images and frame-by-frame motion. The project is distinguished by its use of node-based workflows for building complex image transformations, visual effects, and custom digital brush designs. It utilizes a shader-based brush engine and a node graph to define personalized painting tool behaviors and procedural animations. The

Parity Ethereum is a software implementation of an Ethereum client node that maintains a local copy of the ledger and validates network transactions. It functions as a blockchain network peer and an Ethereum Virtual Machine runtime, providing the environment necessary to process smart contract bytecode and update network state. The project includes systems for cryptographic key management to generate and store the private keys used to sign secure transactions. It enables the operation of a blockchain node and provides mechanisms for Ethereum network synchronization to match the current state

This project is a JavaScript code protection tool designed to transform source code into a version that is difficult for humans to read. Its primary purpose is to protect intellectual property and prevent reverse engineering by altering the original program logic. The tool employs several advanced techniques to hinder analysis, including control flow flattening and the injection of dead code. It can compile functions into custom bytecode executed by an embedded virtual machine and encrypt string literals to prevent static analysis of text. Additional capabilities include anti-debugging mecha

SQLiteStudio is an open-source graphical tool for browsing, editing, and managing SQLite database files. It combines a full-featured SQL editor with syntax highlighting, a visual database schema designer for creating entity-relationship diagrams, and a plugin-based extensibility platform that allows adding custom functionality through C/C++, JavaScript, Tcl, or Python. The application distinguishes itself through its multi-language scripting engine, which embeds JavaScript, Tcl, and Python interpreters to enable user-defined functions and scripts within SQL queries. It supports encrypted data

Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

Empire is a post-exploitation command-and-control (C2) framework designed for red team operations. It deploys and manages agents written in PowerShell, Python, C#, Go, and C across Windows, Linux, and macOS, using encrypted communication channels over HTTP, HTTPS, and SMB. The framework executes over 400 built-in modules for reconnaissance, privilege escalation, credential theft, and lateral movement, and provides a modular engine for authoring custom attack modules. What sets Empire apart is its multi-language agent deployment system, which allows operators to choose implants that suit each

LibreSprite is a digital art application for designing precise pixel characters and objects. It functions as a 2D sprite editor, palette-based image editor, and pixel art animation software. The application specializes in creating frame-based pixel art animations using onion skinning and layer management. It also includes a tiled texture creator for producing seamless repeating patterns and textures through a synchronized tiled viewport. The software covers a broader range of game asset pipeline capabilities, including the creation of static pixel art and the management of fixed color palett

IREE is an MLIR-based compiler toolchain and runtime designed to translate machine learning models from various frameworks into optimized binaries for execution across diverse hardware targets. It provides a unified pipeline to ingest models from PyTorch, TensorFlow, JAX, and ONNX, lowering them into a common intermediate representation for deployment on CPUs, GPUs, and bare-metal embedded systems. The project distinguishes itself through a bytecode virtual machine and a hardware abstraction layer that decouple high-level model logic from specific hardware instruction sets. It supports sophis

Pixel-editor is a browser-based graphics tool designed for the creation and editing of pixel art. It provides a digital drawing environment that allows users to manipulate individual pixels on a grid-based canvas to produce retro-style graphics and sprite assets directly within a web browser. The application features a local storage workspace manager that enables users to maintain a customizable creative workflow. By saving interface preferences and tool visibility settings directly to the browser, the editor allows for persistent workspace configurations tailored to specific project requirem

Liteflow is a component-based rule engine and workflow orchestrator used to define business logic through a chain of reusable components. It utilizes a structured data language to map logic paths, functioning as a dynamic workflow engine for managing sequences of synchronous and asynchronous tasks. The project is distinguished by its support for hot deployment, allowing rule definitions and execution logic to be updated in real time without restarting the application. It also features a multi-language scripting engine that embeds external scripts into business rules to enable flexible logic c

This project is an educational implementation of a relational database engine written in C. It functions as a SQLite clone, demonstrating the internal mechanics of a database system through a C-based systems project that focuses on manual memory management and file I/O. The engine is distinguished by its use of a bytecode virtual machine, which executes database operations by compiling SQL statements into low-level instructions. It utilizes a B-tree database engine to organize records in a balanced tree structure, ensuring efficient insertion, search, and range scanning. The system covers co

Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll