tic80.com

The games and cartridges on tic80.com are listed on the homepage in the NEW & POPULAR CARTS section, below the short introduction to TIC-80. Each entry shows a title, a one-line description, the author's name, and two numbers that appear to be engagement counts. Cartridges can be played directly on the website, and the site also notes that finished games can be packed into a standalone player for other platforms.

What the Cart List Shows

The homepage presents carts as a browsable feed rather than a searchable catalog. From the page evidence, each row follows the same pattern:

• Title in capitals, e.g. BLUEYVANIA, SPEED, HOLLOW KNIGHT DEMAKE
• A short description of the game or demo
• "by" plus the author name, e.g. by fizzii01, by Andrey Listopadov
• Two numbers after the author, which read as a popularity or activity signal

The list mixes full games, demakes, tech demos, and music pieces, so it works as a discovery feed rather than a filtered store.

Examples of Carts You'll See

The current list on the page includes a range of styles:

Several authors appear more than once — Andrey Listopadov has three carts in the visible list — so browsing by author is a practical way to find more work in a style you like.

Playing a Cartridge on the Site

The page states that a finished game becomes a cartridge file, which "can be stored and played on the website." In practice:

1. Open tic80.com and scroll to the NEW & POPULAR CARTS section.
2. Pick a cart from the list.
3. Play it in the browser — no separate download is described for web play.

If you want to keep or share a game outside the site, the page says the cartridge can be packed into a player that runs on all popular platforms and distributed as you wish.

Browsing by Popularity and Author

The two numbers beside each cart give you a rough popularity signal, and the list is ordered roughly from higher to lower counts — BLUEYVANIA leads with 11 and 30, while entries near the bottom sit at 4–5. Use them to judge which carts other visitors engage with most.

To go deeper on a specific creator, note the author name and look for their other carts in the same list. Names like Andrey Listopadov, HanamileH, and plumifrons each have multiple entries visible on the page.

What to Expect from the Carts

Every cart runs inside TIC-80's technical limits: a 240x136 pixel display, a 16-color palette, 256 8x8 color sprites, and 4-channel sound. That's why the list leans toward retro-style games, demakes, and technique demos — the constraints are part of the appeal. If you're evaluating whether a cart fits what you want to play or study, check its description first: entries like VOXEL SPACE and MUSIC DEMO are clearly technical showcases, while BLUEYVANIA and TIC STAR RACERS are full games.

TIC-80 (tic80.com, currently v1.4.0) is a free and open source "fantasy computer" for making, playing, and sharing tiny retro games. You build everything inside one program using its built-in code, sprite, map, and sound editors plus a command line, and you finish with a cartridge file that can be stored and played on the website or packed into a standalone player for distribution. The catch is that all of this happens under fixed technical limits: a 240x136 pixel display, a 16-color palette, 256 8x8 color sprites, and 4-channel sound. If your idea fits inside those constraints, the whole loop from blank project to shareable game stays in one tool.

What you need before starting

• A copy of TIC-80 for your platform (the site presents it as free and open source; the page does not list pricing tiers or account requirements, so treat any login or download conditions as something to confirm on the site itself).
• A game concept small enough for the limits above. A single-screen arcade loop, a short platformer level, or a tiny puzzle fits naturally; a large open-world game does not.
• No external art or audio pipeline is strictly required, since the editors are built in. You can still import assets if you prefer, but the built-in tools are enough for a mini retro game.

The build workflow

The order below follows how the built-in tools relate to each other. Exact menu names and shortcuts are not documented on the page, so use the editor labels you see in your version.

1. Set up the project

Create a new cartridge. This is the file that will hold your code, sprites, map, and sound together, and it is also what you eventually share.

2. Draw sprites

Use the sprite editor to create your 8x8 tiles within the 16-color palette. Keep a consistent palette early; changing it later means reworking art. The 256-sprite budget is shared across everything in the game, so plan characters, tiles, and UI together.

3. Build the map

Place your sprites in the map editor to lay out levels or screens. Because the display is 240x136 pixels, think in screens rather than long scrolling vistas unless you build scrolling yourself.

4. Write the code

Use the code editor to script game logic: input, movement, collision, scoring, and screen transitions. Keep the loop simple and test often, since the small display makes problems visible quickly.

5. Add sound

Use the sound editor to create effects and music within the 4-channel limit. Four channels means you are budgeting, not layering freely: decide early which channels carry music and which carry effects.

6. Use the command line

The built-in command line handles project-level tasks such as running the game and managing the cartridge. Use it to test the full build rather than only previewing individual editors.

7. Verify before sharing

Run the game from start to a natural end point and check:

• Every screen fits within 240x136 and reads clearly at that size.
• Colors stay within the 16-color palette.
• Sprite and map usage stays inside the 256-sprite budget.
• Audio does not exceed 4 channels and does not cut out during busy moments.
• The game starts, plays, and ends without needing a restart.

Sharing your game

You have two routes, and they serve different audiences.

The website route is the shortest path: your cartridge can be stored and played directly on the site, which is also where the community's new and popular carts are showcased. The packed-player route takes more setup but lets you distribute the game as you wish on the platforms the player supports.

Common sticking points

• Running out of sprites. The 256-sprite limit includes tiles, characters, and UI. Reuse tiles aggressively and keep UI minimal.
• Audio dropping out. With only 4 channels, a music track plus several simultaneous effects will collide. Reserve channels or simplify effects.
• Text that is unreadable. At 240x136, small fonts blur. Design text at the pixel level rather than scaling it down.
• Scope creep. The limits are the point of the format. A finished small game shared on the site is worth more than an unfinished large one.

A realistic first project

Aim for something like a single-screen game where the player collects items while avoiding moving hazards, with one music loop and two sound effects. That exercises every editor, stays inside every limit, and produces a cartridge you can store on the website the same day. Once that ships, the packed-player route is a natural next step for distributing it more widely.

A TIC-80 cartridge is the single file you get when you finish a game in TIC-80, the free and open source "fantasy computer" for making, playing and sharing tiny games. You can store and play that cartridge on the TIC-80 website, or pack it into a player that runs on popular platforms and distribute it however you like. This applies to anyone building a mini retro game inside TIC-80's built-in tools; if you only want to play existing games, you don't need to create a cartridge at all.

What the cartridge contains

TIC-80 bundles its development tools into one environment: code, sprite, map and sound editors plus a command line. When you finish, that work is saved as a cartridge file. Because everything the game needs lives in that one file, it can be moved between the website and a standalone player without a separate asset bundle.

The cartridge also inherits the platform's technical limits, which shape what fits inside it:

These constraints are part of the format's appeal: a cartridge is small enough to share easily and runs consistently wherever TIC-80 runs.

How a cartridge is used

There are three practical stages:

1. Create. Work inside TIC-80's editors until the game is playable, then save it as a cartridge file.
2. Store and play on the website. Upload the cartridge to tic80.com, where it can be stored and played in the browser. The site's "New & Popular Carts" section shows this in action — entries like BLUEYVANIA by fizzii01, SPEED by Andrey Listopadov, and BAD APPLE (PCM AUDIO) by HanamileH are cartridges published for others to play.
3. Package and distribute. Export the cartridge into a player that works on all popular platforms, then share it under whatever terms you choose.

Verifying it works

After saving, load the cartridge back into TIC-80 or open it on the website and play through the game. If sprites, maps or audio are missing, the cartridge wasn't saved with all its assets — re-save from the project rather than from a partial export.

Common sticking points

• Expecting more than the limits allow. Plan art and sound around 240x136 pixels, 16 colors, 256 sprites and 4 channels from the start; retrofitting later usually means redrawing.
• Assuming a cartridge is only for the website. It is equally the input for a standalone player, so the same file serves both online play and offline distribution.
• Forgetting the distribution choice is yours. The platform provides the packaging route; how and where you share the result is up to you.

To see finished examples before building your own, browse the cartridge listings on tic80.com and open a few to see how other creators work within the same limits.

TIC-80 is a free and open source fantasy computer for making, playing, and sharing tiny games. It bundles the tools you need to build a mini retro game—code, sprite, map, and sound editors plus a command line—and produces a cartridge file that can be stored and played on the website or packed into a player that runs on all popular platforms for distribution.

What you get in one package

The site describes TIC-80 as a self-contained development environment rather than a standalone engine or editor. The built-in toolset covers the core parts of small-game production:

• Code editor for writing game logic
• Sprite editor for pixel art
• Map editor for level layout
• Sound editor for audio
• Command line for running and managing projects

The output of a project is a cartridge file. That cartridge can be stored and played on the TIC-80 website, or packed into a player that works across popular platforms and distributed however you like.

The technical limits that shape a game

Retro style on TIC-80 comes from fixed constraints applied to the whole creation process. According to the site, these include:

These limits are the design brief, not a barrier: they keep projects small enough to finish and give every cartridge a consistent retro look and feel.

What people are actually publishing

The homepage lists new and popular cartridges, which shows the range the constraints still allow. Examples from the current listing include:

• BLUEYVANIA by fizzii01 — a passion project based on the Bluey TV show with elements from games like Metroid and Zelda
• SPEED by Andrey Listopadov — "Reach for the stars"
• BAD APPLE (PCM AUDIO) by HanamileH — a Bad Apple clip with PCM audio
• HOLLOW KNIGHT DEMAKE by Andrey Listopadov — Hollow Knight's Forgotten Crossroads ported to TIC-80
• NEKOMIMI CLOCK by khuxkm/minerobber — a clock re/demake
• TIC STAR RACERS by deidara — a 3D single- and multiplayer racing game
• SOLAR SYSTEM 3D by maazxp — real-time 3D planets, moons, Saturn rings, and an asteroid belt with ambient music

The mix of platformers, demakes, audio-visual demos, 3D experiments, and fan games indicates that the 240x136, 16-color, 4-channel format supports more than simple arcade clones.

Who it fits

TIC-80 suits you if you want to finish and share a small retro game rather than build a large project: the built-in editors remove setup work, the cartridge format makes distribution simple, and the fixed limits keep scope manageable. If you need high-resolution graphics, many colors, or extensive audio channels, the constraints will work against you—that is the trade-off the fantasy-computer format makes deliberately.

The site identifies the current release as TIC-80 tiny computer v1.4.0.

TIC-80 is a free and open source fantasy computer for making, playing and sharing tiny games, and its technical limits are fixed by design: a 240x136 pixel display, a 16-color palette, 256 8x8 color sprites, and 4-channel sound. Every game made in it works inside those constraints, which is what produces the retro look and the small, cartridge-sized results the platform is built around.

The core limits at a glance

These are the numbers TIC-80 states for its built-in toolchain, which includes code, sprite, map, and sound editors plus a command line.

How each limit shapes the result

240x136 display

The resolution is close to a scaled-down classic console screen. A single 8x8 sprite covers a small fraction of the width, so detailed scenes have to be built from tiles and repeated patterns. Games that need readable text or busy action must design around the small viewport rather than scale up art.

16-color palette

Because the palette is fixed at 16 colors, art direction becomes a selection problem: pick a coherent set early and reuse it across sprites, maps, and UI. Gradients and anti-aliasing are effectively off the table, which pushes games toward flat, high-contrast pixel art.

256 8x8 sprites

The sprite budget is shared between everything visual: player, enemies, tiles, particles, and interface elements. A game with many distinct characters or animation frames will run out quickly, so creators often reuse sprites with palette swaps or flip them for variety.

4-channel sound

Four voices total means music and sound effects compete for the same channels. A common approach is to reserve channels for effects and keep music sparse, or to cut effects during musical passages.

Why these limits define the retro style

The constraints are not incidental; they are the reason TIC-80 games look and sound like early console titles. Small resolution forces chunky pixels, the 16-color palette forces bold flat art, the sprite cap encourages reuse and clever tiling, and four channels produce the characteristic thin, melodic sound. The output is a cartridge file that can be stored and played on the website, or packed into a player that runs on all popular platforms and distributed as you wish.

What this means if you want to build a game

• Plan art around the palette first. Choose your 16 colors before drawing sprites so everything stays consistent.
• Budget sprites deliberately. Count player, enemy, tile, and UI sprites early; reuse and palette-swap where possible.
• Design for the small screen. Test readability at 240x136 rather than assuming you can zoom out later.
• Separate music and effects. Decide which channels carry music and which carry sound effects before composing.

The limits are strict, but they are also the point: they keep projects small enough to finish and give every TIC-80 game a recognizable visual and audio identity.