Nintendo Ds Emulator Js -
The Rise of the Nintendo DS Emulator in JavaScript: Gaming in the Browser
The Nintendo DS (Dual Screen) revolutionized handheld gaming with its unique dual-display setup and touchscreen capabilities. Historically, playing these games on other devices required heavy native applications. However, the landscape has shifted with the emergence of Nintendo DS emulators written in JavaScript (JS). These projects allow users to relive classics like Pokémon or Mario Kart directly in a web browser without installing any software. Top Nintendo DS Emulators for the Web
While native emulators like DeSmuME and melonDS are the gold standard for performance, several JS-based projects have successfully ported this experience to the web.
In the late hours of a rainy Tuesday, a developer sits before a glowing terminal. Their goal is ambitious: reviving the dual-screened magic of the Nintendo DS entirely within a web browser using JavaScript The Technical Backbone
They start with the legends of the open-source community. Projects like Desmond.js DeSmuME-wasm
serve as the foundation, bridging the gap between old-school C code and the modern web via WebAssembly The developer discovers EmulatorJS
, a powerful web-based frontend that makes retro gaming feel native to the browser. With a few lines of code, they integrate the "core"—the engine that mimics the DS's hardware—and map the virtual buttons to a keyboard. The Implementation Setting the Stage : They set up a local server and install dependencies using The Bridge : Using a project like DS Anywhere
, they create a TypeScript bridge that connects the emulator's logic to a sleek React or Vue interface. Loading the Memories : The developer adds a file picker. When a user selects a
ROM file, the JavaScript engine begins its work, simulating the two screens that once defined a generation of gaming. The Climax
As the terminal pulses, the developer hits "Refresh." A classic startup sound echoes through the speakers. On the screen, two virtual displays appear—one for the action, one for the touch controls. It isn't just code anymore; it's a portable console reborn in a tab, protected by the security of a browser sandbox.
The story ends not with a "Game Over," but with a high score, proving that with enough JavaScript, the past is never truly gone. code snippet for embedding one of these emulators on your own site?
EmulatorJS/EmulatorJS: A web-based frontend for RetroArch - GitHub
Challenge 3: The 3D Graphics Pipeline
The DS’s 3D hardware is a weird hybrid. It has no Z-buffer (uses a "painter's algorithm" with W-buffering), supports 4 hardware lights, and uses 4x4 matrices that must be converted to 3x4 for its internal math. nintendo ds emulator js
Porting the software renderer to JavaScript is slow. Porting the OpenGL renderer to WebGL is the only viable path. But WebGL doesn’t support DS-specific features like "toon shading" or "edge marking" natively. Emulators have to recompile DS shader microcode into GLSL on the fly, inside a JavaScript string, at 60fps. It’s a miracle it works at all.
The Future of Web Emulation
The success of DS emulation in JavaScript proves that the web is ready for high-performance gaming. As WebAssembly continues to mature, we can expect to see more complex systems—perhaps even Nintendo 3DS or early PlayStation 2 titles—running smoothly in Chrome and Firefox.
The next time you have a few minutes to spare, open a tab and boot up a classic DS title. It’s a testament to how far web development has come that an entire handheld console can now live comfortably inside your browser.
Are you a developer interested in emulation? Check out the source code for melonDS.js on GitHub to see how they bridge C++ core logic with JavaScript interfaces.
Here’s a compact, ready-to-run HTML document that embeds a JavaScript-based Nintendo DS emulator (using the melonJS core via EmulatorJS) so you can load and play DS ROMs directly in your browser.
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> <title>Nintendo DS Emulator JS | Web-Based Dual-Screen Play</title> <style> * user-select: none; -webkit-tap-highlight-color: transparent;body background: linear-gradient(145deg, #0a0f1e 0%, #0c1222 100%); min-height: 100vh; display: flex; justify-content: center; align-items: center; font-family: 'Segoe UI', 'Inter', system-ui, -apple-system, 'Roboto', monospace; margin: 0; padding: 20px; /* main emulator card */ .emulator-container background: rgba(0, 0, 0, 0.65); backdrop-filter: blur(8px); border-radius: 2.5rem; padding: 1.2rem 1.5rem 1.8rem 1.5rem; box-shadow: 0 25px 45px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.05); transition: all 0.2s ease; /* canvas wrapper + dual screen layout */ .ds-screen-wrapper background: #1e1f2c; border-radius: 1.8rem; padding: 1rem; box-shadow: inset 0 0 8px rgba(0,0,0,0.6), 0 12px 28px rgba(0,0,0,0.4); .ds-flex display: flex; flex-direction: column; gap: 1rem; /* top & bottom screen containers */ .screen-card background: #000000; border-radius: 1.2rem; overflow: hidden; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.5); transition: transform 0.1s ease; canvas display: block; width: 100%; height: auto; background: #0f0f17; cursor: pointer; /* control bar */ .control-panel display: flex; flex-wrap: wrap; justify-content: center; gap: 0.9rem; margin-top: 1.5rem; align-items: center; button background: #2a2e3f; border: none; color: white; font-weight: 600; font-size: 0.85rem; padding: 0.7rem 1.3rem; border-radius: 3rem; display: inline-flex; align-items: center; gap: 0.5rem; cursor: pointer; backdrop-filter: blur(4px); transition: all 0.2s ease; box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3); font-family: inherit; letter-spacing: 0.3px; button i font-style: normal; font-weight: bold; font-size: 1.1rem; button:hover background: #3d435b; transform: scale(0.97); button.primary background: #5a3e8f; box-shadow: 0 4px 12px rgba(90, 62, 143, 0.4); button.primary:hover background: #7048b0; .file-label background: #2d3348; padding: 0.7rem 1.3rem; border-radius: 3rem; font-size: 0.85rem; font-weight: 600; cursor: pointer; transition: 0.2s; display: inline-flex; align-items: center; gap: 0.5rem; .file-label:hover background: #3f455e; input[type="file"] display: none; .status-msg background: #0b0e16aa; backdrop-filter: blur(12px); padding: 0.4rem 1rem; border-radius: 2rem; font-size: 0.75rem; color: #b9c7e6; font-family: monospace; text-align: center; margin-top: 0.8rem; .touch-hint font-size: 0.7rem; text-align: center; color: #7e84a3; margin-top: 1rem; background: #10131e60; border-radius: 2rem; padding: 0.3rem 1rem; width: fit-content; margin-left: auto; margin-right: auto; @media (max-width: 700px) .emulator-container padding: 0.8rem; button, .file-label padding: 0.5rem 1rem; font-size: 0.75rem; </style> <!-- EmulatorJS core + DS module (lightweight standalone version) --> <!-- We use the official CDN for EmulatorJS: dedicated NDS core --> <script src="https://cdn.emulatorjs.org/stable/data/emulator.min.js"></script></head> <body> <div class="emulator-container"> <div class="ds-screen-wrapper"> <div class="ds-flex"> <!-- Top Screen (main display) --> <div class="screen-card" id="top-screen-container"> <canvas id="ds-top-canvas" width="256" height="192" style="width:100%; height:auto; image-rendering: crisp-edges; image-rendering: pixelated;"></canvas> </div> <!-- Bottom Screen (touch + display) --> <div class="screen-card" id="bottom-screen-container"> <canvas id="ds-bottom-canvas" width="256" height="192" style="width:100%; height:auto; image-rendering: crisp-edges; image-rendering: pixelated;"></canvas> </div> </div> </div>
<div class="control-panel"> <label class="file-label" id="rom-select-label"> 📁 Load NDS ROM (.nds) <input type="file" id="rom-file-input" accept=".nds, .zip"> </label> <button id="btn-reset">🔄 Reset Game</button> <button id="btn-pause-play">⏸️ Pause</button> </div> <div class="status-msg" id="status-message"> ⚡ Ready — select a Nintendo DS ROM (NDS file) </div> <div class="touch-hint"> 🖱️ TOUCH SUPPORT: Click/tap on the BOTTOM screen to simulate stylus input. Gamepad mapping: Arrow Keys / Z X A S (see console) </div></div>
<script> // ---------------------------------------------- // EmulatorJS DS instance with dual canvas rendering // Using the melonDS / DeSmuME core (NDS) via EmulatorJS. // EmulatorJS provides a unified API: window.EJS // ----------------------------------------------
let emulatorInitialized = false; let currentEJS = null; // reference to the EJS core object let isRunning = false; let currentRomFile = null; let pauseBtn = document.getElementById('btn-pause-play'); let resetBtn = document.getElementById('btn-reset'); let statusDiv = document.getElementById('status-message'); let romInput = document.getElementById('rom-file-input'); // Canvas elements (top & bottom) const topCanvas = document.getElementById('ds-top-canvas'); const bottomCanvas = document.getElementById('ds-bottom-canvas'); // We'll store canvas contexts for potential custom drawing, but EmulatorJS will manage them. // EmulatorJS by default creates canvas elements inside a container, but we need to hook into specific containers. // Instead of letting EJS create its own, we manually assign using EJS.config and use EJS_addCanvas hook. // According to EJS documentation: you can set "canvas" and "canvasTouch" for dual screen. // Function to update UI status function setStatus(msg, isError = false) statusDiv.innerHTML = msg; statusDiv.style.color = isError ? "#ffa098" : "#b9c7e6"; console.log("[DS Emu] " + msg); // Cleanup previous emulator instance if exists function destroyEmulator() if (currentEJS && typeof currentEJS.destroy === 'function') try currentEJS.destroy(); catch(e) console.warn(e); // remove any leftover EJS containers if any const oldContainers = document.querySelectorAll('.ejs_container'); oldContainers.forEach(el => el.remove()); emulatorInitialized = false; currentEJS = null; isRunning = false; // Configure and launch emulator with given ROM file (ArrayBuffer or Blob) async function initEmulatorWithRom(romFile) destroyEmulator(); // Reset canvases to black placeholder const ctxTop = topCanvas.getContext('2d'); const ctxBottom = bottomCanvas.getContext('2d'); ctxTop.fillStyle = "#0a0a14"; ctxTop.fillRect(0, 0, topCanvas.width, topCanvas.height); ctxBottom.fillStyle = "#0a0a14"; ctxBottom.fillRect(0, 0, bottomCanvas.width, bottomCanvas.height); ctxTop.fillStyle = "#3a3a55"; ctxTop.font = "12px monospace"; ctxTop.fillText("Loading DS core...", 10, 30); ctxBottom.fillStyle = "#3a3a55"; ctxBottom.fillText("Please wait", 10, 30); setStatus("Initializing DS emulator core..."); // EmulatorJS configuration for Nintendo DS (dual screen + touch) // We explicitly provide the canvas elements: top screen = 'canvas', bottom = 'canvasTouch' // Also we need to set the paths to the cores (CDN already provides) window.EJS_canvas = topCanvas; // primary display window.EJS_canvasTouch = bottomCanvas; // touch screen (bottom) window.EJS_core = 'nds'; window.EJS_pathtodata = 'https://cdn.emulatorjs.org/stable/data/'; window.EJS_gameUrl = null; // we'll load ROM manually via file window.EJS_color = "#2a2e3f"; window.EJS_startOnLoad = false; window.EJS_autoSave = true; window.EJS_batterySave = true; // Additional config for dual screen orientation (horizontal/vertical) but we enforce fixed containers window.EJS_screenOrientation = "vertical"; // top-bottom layout matches our CSS // We need to wait for EJS to be fully loaded and then load the ROM if (typeof window.EJS === 'undefined') setStatus("Error: EmulatorJS library not loaded. Check CDN.", true); return false; try // EJS constructor expects an element ID or container, but we rely on global config + EJS_start function. // According to docs: after setting config, call window.EJS_start() to initialize. // But modern approach: new EJS(containerId) and override. // Safer: use the global EJS object and run start. if (window.EJS_emulator) // if previous instance inside EJS_emulator, clean if (window.EJS_emulator.destroy) window.EJS_emulator.destroy(); window.EJS_emulator = null; // Create emulator instance in a hidden div? but we already assigned canvases // The EJS script exposes "EJS" constructor. We'll create an instance attached to dummy container but canvases override. const dummyDiv = document.createElement('div'); dummyDiv.style.display = 'none'; document.body.appendChild(dummyDiv); currentEJS = new window.EJS(dummyDiv); // override canvases after creation if (currentEJS && currentEJS.setCanvas) currentEJS.setCanvas(topCanvas, bottomCanvas); else // manually patch: assign core canvases if (currentEJS.core) currentEJS.core.canvas = topCanvas; currentEJS.core.canvasTouch = bottomCanvas; // Load ROM from file const romData = await romFile.arrayBuffer(); const romUint8 = new Uint8Array(romData); setStatus("Loading NDS ROM..."); if (currentEJS && typeof currentEJS.loadROM === 'function') await currentEJS.loadROM(romUint8); else if (currentEJS && currentEJS.core && typeof currentEJS.core.loadROM === 'function') await currentEJS.core.loadROM(romUint8); else // fallback: use EJS_loadState? alternative approach: use global EJS_startGame // For EmulatorJS v3+ we can pass the file directly window.EJS_gameFile = romFile; if (window.EJS_startGame) await window.EJS_startGame(romFile); currentEJS = window.EJS_emulator; else throw new Error("loadROM method not found in EmulatorJS instance"); isRunning = true; emulatorInitialized = true; pauseBtn.innerHTML = "⏸️ Pause"; setStatus("✅ Nintendo DS game running! Use bottom screen for touch (mouse/tap)."); // ensure focus for keyboard controls topCanvas.focus(); dummyDiv.remove(); return true; catch (err) console.error("Emulator init error:", err); setStatus(`Failed to load ROM: $err.message`, true); destroyEmulator(); return false; // Helper: load rom from File object async function loadRomFromFile(file) if (!file) return; if (!file.name.toLowerCase().endsWith('.nds') && !file.name.toLowerCase().endsWith('.zip')) setStatus("Please select a .nds (Nintendo DS ROM) or .zip file", true); return; currentRomFile = file; const success = await initEmulatorWithRom(file); if (!success) setStatus("Emulator failed to start. Check ROM compatibility or core.", true); // Event: file picker romInput.addEventListener('change', (event) => const file = event.target.files[0]; if (file) loadRomFromFile(file); ); // Reset emulator (reload same ROM) resetBtn.addEventListener('click', async () => if (!currentRomFile) setStatus("No ROM loaded. Please select a .nds file first.", true); return; setStatus("Resetting game..."); if (currentEJS && typeof currentEJS.reset === 'function') currentEJS.reset(); else if (currentEJS && currentEJS.core && typeof currentEJS.core.reset === 'function') currentEJS.core.reset(); else // fallback: reload emulator await initEmulatorWithRom(currentRomFile); setStatus("Game reset."); ); // Pause / Resume pauseBtn.addEventListener('click', () => if (!emulatorInitialized ); // Handle touch events for bottom screen (stylus simulation) // EmulatorJS often supports touch automatically if we map canvasTouch. But to ensure, // we add explicit touch/mouse events that translate coordinates to bottom canvas and send to emulator core. function getRelativeCoords(canvas, e) const rect = canvas.getBoundingClientRect(); const scaleX = canvas.width / rect.width; // logical width 256 const scaleY = canvas.height / rect.height; let clientX, clientY; if (e.touches) clientX = e.touches[0].clientX; clientY = e.touches[0].clientY; else clientX = e.clientX; clientY = e.clientY; let x = (clientX - rect.left) * scaleX; let y = (clientY - rect.top) * scaleY; x = Math.min(Math.max(0, x), canvas.width); y = Math.min(Math.max(0, y), canvas.height); return x, y ; // Function to forward touch/pen event to emulator function sendTouchToEmulator(x, y, isPressed) let touchActive = false; function handleBottomStart(e) e.preventDefault(); const coords = getRelativeCoords(bottomCanvas, e); touchActive = true; sendTouchToEmulator(coords.x, coords.y, true); function handleBottomMove(e) if (!touchActive) return; e.preventDefault(); const coords = getRelativeCoords(bottomCanvas, e); sendTouchToEmulator(coords.x, coords.y, true); function handleBottomEnd(e) e.preventDefault(); if (touchActive) const coords = getRelativeCoords(bottomCanvas, e); sendTouchToEmulator(coords.x, coords.y, false); touchActive = false; // register mouse + touch events on bottom canvas (touch screen) bottomCanvas.addEventListener('mousedown', handleBottomStart); window.addEventListener('mousemove', (e) => if (touchActive) handleBottomMove(e); ); window.addEventListener('mouseup', handleBottomEnd); bottomCanvas.addEventListener('touchstart', handleBottomStart); bottomCanvas.addEventListener('touchmove', handleBottomMove); bottomCanvas.addEventListener('touchend', handleBottomEnd); bottomCanvas.addEventListener('touchcancel', handleBottomEnd); // Keyboard mapping for physical buttons (optional, but adds classic DS feel) // Map keys: Arrow Keys = D-Pad, Z = A, X = B, A = Y, S = X, Q = L, W = R, Enter = Start, Shift = Select // We will listen to keydown/keyup and feed to emulator if supported. const keyMap = 'ArrowUp': 'up', 'ArrowDown': 'down', 'ArrowLeft': 'left', 'ArrowRight': 'right', 'z': 'a', 'Z': 'a', 'x': 'b', 'X': 'b', 'a': 'y', 'A': 'y', 's': 'x', 'S': 'x', 'q': 'l', 'Q': 'l', 'w': 'r', 'W': 'r', 'Enter': 'start', 'Shift': 'select' ; function sendButtonState(button, pressed) window.addEventListener('keydown', (e) => const key = e.key; const mapped = keyMap[key]; if (mapped) e.preventDefault(); sendButtonState(mapped, true); // optional: also support space for start? not needed ); window.addEventListener('keyup', (e) => const key = e.key; const mapped = keyMap[key]; if (mapped) e.preventDefault(); sendButtonState(mapped, false); ); // Informational note for EJS auto setup // In case the emulator core expects a specific global initialization if (typeof window.EJS === 'undefined') setStatus("⚠️ EmulatorJS library not loaded. Check internet connection.", true); else setStatus("DS Emulator ready. Click 'Load NDS ROM' to start."); // Preload a simple placeholder but no game // On window load, ensure canvases have proper aspect and size (scaling) window.addEventListener('load', () => // enforce initial canvas pixel dimensions (NDS native 256x192) topCanvas.width = 256; topCanvas.height = 192; bottomCanvas.width = 256; bottomCanvas.height = 192; const ctxTop = topCanvas.getContext('2d'); const ctxBottom = bottomCanvas.getContext('2d'); ctxTop.fillStyle = "#14141f"; ctxTop.fillRect(0,0,256,192); ctxTop.fillStyle = "#fff8e7"; ctxTop.font = "12px monospace"; ctxTop.fillText("Nintendo DS Emulator", 48, 80); ctxTop.fillStyle = "#aaadcc"; ctxTop.fillText("Load .nds file", 80, 120); ctxBottom.fillStyle = "#14141f"; ctxBottom.fillRect(0,0,256,192); ctxBottom.fillStyle = "#b3b6e0"; ctxBottom.font = "10px monospace"; ctxBottom.fillText("Touch Screen Ready", 70, 100); );
</script> </body> </html>
The Dream of Playing NDS Games in the Browser
It was a typical Wednesday evening when Alex, a passionate gamer and developer, stumbled upon an old Nintendo DS console collecting dust in his attic. As he rummaged through the old games and accessories, he remembered the good old days of playing Pokémon, Mario Kart, and Nintendogs on the go. The Rise of the Nintendo DS Emulator in
However, as he tried to fire up the console, he realized it was dead. The screen was cracked, and the device just wouldn't turn on. Alex thought to himself, "There must be a way to play these classic games on modern devices."
His curiosity piqued, Alex started researching online and discovered that there were already emulators available for various platforms, including PC and mobile. However, he was specifically interested in running NDS games in the browser.
The Challenge of Emulation
Alex soon learned that creating a Nintendo DS emulator was no easy feat. The NDS had a unique dual-core processor, and its games were designed to take advantage of both cores. This made emulation a significant challenge.
Undeterred, Alex dove deeper into the world of emulation. He studied the NDS architecture, learning about its ARM9 and ARM7 processors, memory management, and graphics processing. He also explored existing emulators, analyzing their strengths and weaknesses.
As he explored the world of JavaScript, Alex discovered that it was possible to create a basic emulator using the language. He found libraries like WebAssembly and Emscripten, which allowed him to compile C++ code (often used for emulation) into JavaScript.
The Birth of a Project
With a clear goal and a good understanding of the challenges ahead, Alex started working on his Nintendo DS emulator in JavaScript. He named it "NDS.js."
The initial progress was slow, but Alex was determined to see it through. He poured over documentation, writing code to emulate the NDS's processors, memory, and graphics. He also experimented with WebAssembly, using it to optimize performance-critical parts of the emulator.
As NDS.js began to take shape, Alex started testing it with simple games like Tetris and Pokémon. The results were promising, with the games running at a decent speed and displaying correctly.
Overcoming Hurdles
However, as Alex progressed, he encountered numerous obstacles: Are you a developer interested in emulation
- Performance: JavaScript, although improved significantly over the years, still struggled to match the performance of native code. Alex had to optimize every aspect of the emulator to achieve acceptable speeds.
- Compatibility: The NDS library was vast, and Alex needed to ensure that his emulator could handle a wide range of games. He had to debug and refine the emulator continuously to improve compatibility.
- Graphics and Audio: The NDS had a unique graphics processing unit (GPU) and audio processing unit (APU). Alex had to accurately emulate these components to produce high-quality graphics and sound.
The Breakthrough
After months of hard work, Alex finally made a significant breakthrough. He successfully ran Pokémon Diamond, a popular NDS game, at a smooth framerate in the browser.
The achievement was a milestone for NDS.js, and Alex felt a tremendous sense of accomplishment. He shared his progress on social media and online forums, where it sparked interest and excitement among gamers and developers.
The Future of NDS.js
Today, NDS.js is an open-source project, actively maintained and improved by Alex and a community of contributors. Although it's still a work in progress, the emulator has come a long way.
The project has sparked interest in retro gaming and emulation, inspiring new generations of developers to explore the world of classic gaming.
As for Alex, he's proud of what he's achieved and looks forward to continuing to develop NDS.js, making it possible for more people to enjoy classic NDS games in their browsers.
2. SkyEmu (The New Blood)
SkyEmu is a newer, multi-platform emulator written in C. Its author, skylersaleh, prioritizes a clean codebase that compiles effortlessly to WASM. The JavaScript wrapper for SkyEmu is lean. You can find test builds online where the entire DS emulator loads in under 2 seconds.
How to Use a Nintendo DS Emulator JS (Step-by-Step)
Using a web-based DS emulator is straightforward. Here’s a generic guide:
- Find a legitimate emulator site (e.g.,
melonds.kdave.czfor MelonDS web demo, orskyemu.app). - Do not download any "plugin" or "installer"—real JS emulators run entirely in your browser.
- Obtain your game ROMs legally (dump them from your own physical cartridges). Never download copyrighted ROMs unless you own the original game.
- Click "Load ROM" or drag-and-drop your
.ndsfile onto the browser window. - Map controls – Most emulators let you use keyboard (e.g., W/A/S/D for D-pad, J/K for A/B buttons) or connect a Bluetooth controller.
- Save your game – Use in-game saves (which write to a virtual EEPROM) or emulator save states.
The User Experience: Plug and Play
The beauty of a JS emulator is the friction-free experience. Here is how the typical workflow looks today:
- Find a Host: You navigate to a website hosting the emulator core (often a static HTML page).
- Load the ROM: Because of copyright laws, most web emulators don’t come with games. You must supply your own legally dumped ROM file from your own game cartridges.
- Play: Once loaded, you get a fully interactive interface.
Conclusion
A Nintendo DS emulator implemented in JavaScript/WASM is technically viable and can deliver playable experiences in modern browsers, especially when using a WASM core and GPU-accelerated rendering. Expect trade-offs: variable performance across devices, incomplete hardware feature coverage, and important legal constraints around BIOS and ROM distribution.
Mobile Support
Perhaps the most ironic twist is that playing DS games on a modern smartphone via a browser is actually an incredible experience. Your phone is roughly the same size as a DS (folded), and touching the screen to play Pokémon or Zelda feels incredibly natural—moreso than using a mouse on a PC.
The Legal Landscape
It is impossible to discuss emulation without touching on legality. Emulators themselves are perfectly legal; they are simply software that mimics hardware. However, ROMs (the game files) are a legal gray area.
Downloading ROMs for games you do not own is generally considered piracy. If you want to try a JS emulator, the best (and safest) route is to "dump" your own game cartridges using homebrew tools or to search for "Homebrew" games—independent games released for free by developers.