Semi-native apps
Status: design agreed with the owner on 2026-11-12; nothing built yet. Raised by the owner on 2026-11-10 with EDGEhack’s Netrunner bench add-on, and on the schedule after #24. The spikes come first, and the cursor spike (S1) decides whether the rest goes ahead as drawn here.
What they are
A semi-native app is a REDnode app that looks and feels like part of the game’s own UI, but is drawn by REDnode as a web page. The player never presses F10 for it.
| Quality | What it means |
|---|---|
| Shown by the game or by code | It appears on a game event (a click on one of the game’s own ink buttons, a recipe selected in the crafting menu, a menu opening) or when a mod’s own code shows it. It is never one of the F10 overlay’s windows |
| One cursor, where the game has one | On the game’s screens with a cursor (the pause menu, the main menu, the inventory, the crafting bench): while the cursor is outside the app it belongs to the game, and when it crosses into the app the app gets it, with no F10 or key, and the cursor looks the same all the way |
| Mapped inputs in the world | In gameplay there is no cursor, as in the game itself. A key or button (or another trigger) shows the app, and while it shows it answers its own mapped keys and controller buttons, the way the game’s quickhack wheel and interaction prompts do |
| Input is optional | An app need not take any input at all: a holocall, a video, a visual effect only shows. Taking input is something an app asks for (the cursor on game screens, mapped keys in the world). An app that asks for none never stops the cursor or a key from reaching the game, so its clicks pass straight through, as a HUD widget’s do |
| Paused, with the cursor | An app may also pause the game world, so nothing in it moves, and show the game’s cursor (the one the pause menu has) inside itself, with full control of input until it closes. The pause menu itself does not open: the app is what shows. Mini-games will mostly want this |
| The game’s look | Its elements look exactly like the game’s ink: the same colors, text, frames and cursor. It can use REDnode’s ink markup (.ink.html) drawn in HTML |
| More than ink can do | Being a web page, it can also draw anything ink cannot: three.js scenes, canvas animation, video, mini-games, holocalls |
| Managed like any package | It is listed in the Mod Manager, switched on and off and given permissions there, and its logs, debugger and hot reload work like any other package’s |
How it differs from what exists
| F10 overlay window | HUD widget | REDnode ink (ink API) |
Semi-native app | |
|---|---|---|---|---|
| Drawn by | Chromium, composited by the plugin | Chromium | The game’s ink | Chromium |
| Shown | While the player is in the overlay (or pinned to the HUD) | Always, hidden in menus and scenes as asked | When the package builds it | On a game event or a call |
| Takes input | In F10’s interactive mode only | Never | Through the game’s own input | On game screens, when the cursor is over it; in the world, its mapped keys and buttons while it shows. No F10 |
| Cursor | REDnode’s arrow, drawn by the plugin | None | The game’s own | On game screens, the game’s, continued over the app; in the world, none |
| Look | Any (the UI kit) | Any | The game’s, exactly | The game’s, copied; plus anything a page can draw |
So the parts that are new are showing on a trigger, input with no F10 (mapped keys in the world), and the cursor crossing over on game screens. HUD widgets already show outside F10 and never take input, and overlay windows already take input in interactive mode. A semi-native app sits between them.
What we already have
| Piece | Where it is today | What it gives semi-native apps |
|---|---|---|
| Transparent, borderless pages of any shape | O1 to O4 (docs/overlay.md) |
The app’s surface |
| Clicks pass through transparent areas | The plugin’s alpha map (0.12.1) | The hit test that says whether the cursor is “in” the app |
| Windows shown outside F10, hidden with menus, scenes or photo mode | HUD widgets, hideWith, the plugin’s ui-state |
Showing without the overlay, and hiding rules |
| A cursor drawn from a texture by the compositor | native/src/overlay/cursor.hpp (0.26.7) |
Drawing the game’s cursor over the app |
| Placing things per frame from game-thread reads | World pins (WP1, WP2: ReadCamera, pins.cpp) |
The pattern for reading the game cursor’s place every frame |
| Reading the game’s ink: layers, trees, the widget under a point | UT2 (ink.layers, ink.read, ink.at, inkread.cpp) |
Finding the game’s cursor layer and the buttons to listen on |
| A script class that hears ink callbacks | REDnodeInkListener (native/scripts/REDnodeInk.reds) |
Listening on a game button’s OnRelease, if it can be registered on the game’s own widgets (S4) |
| Script events into REDnode | REDnode_Emit, REDnode_EntityText |
A mod’s own redscript calling REDnode to show an app |
| The game’s colors and text styles | The game look (docs/ink.md, “The game look”), from main_colors.inkstyle |
The look in HTML |
| Ink markup | UT1 (ink.parse, ink.load, .ink.html) |
One markup for an ink screen and its HTML copy |
| Full-screen pages, solo mode, pointer lock | #32, O10, pointer lock | Mini-games and full-screen moments |
How it would work
Two places an app can show
An app follows the game’s own rule for input: a cursor only where the game shows one (decided with the owner on 2026-11-12).
| Over a game screen with a cursor (the pause menu, the main menu, the inventory, the crafting bench, a popup with a cursor) | In the world (gameplay) | Paused by the app (from the world) | |
|---|---|---|---|
| The game’s cursor | Exists. The game draws it as ink and moves it from the mouse. The Windows cursor is hidden and free (the cursor-flicker run, docs/overlay.md) |
None. The mouse turns the camera, and the game holds the Windows cursor at the screen’s centre | The game’s cursor (as the pause menu has it), drawn inside the app. No game menu opens |
| How the app takes input | The game’s cursor carries on over the app (the cursor crossover) | No cursor. The app is shown by a key or button (or a game event or a call), and while it shows it answers its mapped keys and controller buttons, as the game’s quickhack wheel and interaction prompts do. The camera and movement stay the game’s unless the app needs those keys too (S3) | The app pauses the game world (nothing moves: people, cars, time) and takes all input (mouse, keys, controller) until it closes; then the world moves again. Like the game’s own Breach Protocol, but drawn by the app |
| Examples | A panel beside the crafting menu’s recipe list, a quickhack preview in the cyberdeck screen | A holocall (display only), a contextual panel with key prompts, a mini-game played with keys or a controller | A mini-game played with the mouse, a full-screen bench or terminal UI |
An app that only displays (a holocall, an animation) needs no input at all and works in all three from the start. An app that wants a cursor in the world pauses the game (the third column), opens a game screen that has one, or is an F10 window as today.
Two ways to do the paused mode, for spike S6:
| How | For | Against | |
|---|---|---|---|
| P1. Pause the world and take the input in the plugin (the owner’s meaning) | Stop the world with the game’s time system (TimeSystem.SetPausedState, already called by the H1b swap spike), with no menu opened, and take all input for that one app the way F10’s interactive mode does, drawing a copy of the game’s cursor (S1’s images) |
The world stops and only the app shows. Built from proven parts: interactive mode’s input, the virtual cursor, the cursor texture | The cursor is a copy, moved by REDnode. What else the game does when it pauses (the HUD, sounds, saving) is not done unless REDnode does each (unverified which matter) |
| P2. Open a game screen (the fallback) | Open an empty game menu (the rednode_screen entry planned for I5 in docs/design.html), which stops the world and draws the game’s own cursor as in any menu, with the app over it |
The game’s own pause and its real cursor | A menu, not just a stopped world. Needs the rednode_screen entry, which is unverified (I5), and S1’s crossover |
Showing
A package declares the app in its manifest, "kind": "native" (proposed), and shows and hides it from its code. The triggers would come in this order, from the cheapest:
| Trigger | How | Risk |
|---|---|---|
| A call from the package | app.show() / app.hide() in the rednode package, from a Node mod or the page itself |
None: it is a window open and hide |
| A key or controller button in the world | The app’s manifest names its key (rebindable by the player, as the overlay’s F10 could be), and the plugin shows the app on it | Low for keys (the plugin already hears F10 before the game). Controller buttons are not read by the plugin today (S3) |
| A game state | The ui-state the plugin already sends (menu, scene, photo mode), and which menu is open |
Telling one menu from another is not read today (IsInMenu only). I1 found the menu list and scenarios, so it looks feasible (unverified) |
| A click on a game button | Find the button with UT2’s reads, register a REDnodeInkListener on it for OnRelease |
Unverified: whether a listener registered from outside on the game’s widget fires, and how to find the button again after the menu rebuilds it (S4) |
| A mod’s own redscript | A mod’s .reds calls a REDnode function (like REDnode_Emit, with a package name and data), and REDnode passes it to the package |
Low. It needs the modder to write redscript, but it can hook anything the game does |
The cursor (game screens only)
The proposal is the owner’s model. While the cursor straddles the app’s edge, the game draws its own cursor under the app, and the app draws an exact copy over it, clipped to the app’s opaque pixels. Where the app is transparent you see the game’s cursor, and where it is opaque you see the copy. Lined up, they read as one cursor.
That works only if the copy is in the same place in the same frame and has the same look (the same image, hover state and click animation). The game’s cursor is an ink widget (CursorGameController, with contexts such as hover, and click and hold animations), and the overlay is drawn after the whole game frame, so it always covers the game’s cursor. What the spike has to settle:
| Question | Why it matters |
|---|---|
| Where is the game’s cursor each frame, in screen pixels? | REDnode’s own arrow is moved by summing raw mouse input, which drifts from the game’s cursor (the game applies its own speed). The copy has to read the game’s place, probably from the cursor widget or inkCursorInfo.pos on the game thread, as pins read the camera |
| Is that place read in the same frame the game draws it? | One frame late shows as a seam on the app’s edge while moving |
| What does the cursor look like, and can we draw it? | Its images are in the player’s game files (the cursor layer’s cursorResource). REDnode cannot ship them, so it would read them from the player’s game through REDbridge at first use, as Sound Search does with sounds |
| Can the game’s cursor be hidden and shown? | The game has inkMenuLayer_SetCursorVisibility and a cursor widget we can set to opacity 0. That is the fallback: hide the game’s cursor while it is over the app and draw the copy whole, so a lag or a look mismatch never shows twice |
| Whose hover state shows over the app? | Over the app, game widgets under it may still think they are hovered (the game’s cursor turns to its hover look, and things under the app highlight). Over the app the copy should follow the app’s own hover, not the game’s |
There are three ways to draw it, in the order to try:
| How | For | Against | |
|---|---|---|---|
| A. Copy over the straddle (the owner’s model) | The game’s cursor is always drawn; the copy is drawn clipped to the app’s opaque pixels | Seamless at the edge, the game’s own cursor everywhere else | Needs a per-frame match of place and look |
| B. Hand over at the edge | While the cursor’s point is over the app, hide the game’s cursor and draw the copy whole | Forgiving: no seam to see | The swap is visible when the cursor straddles the edge (half the cursor over a transparent area) |
| C. Draw the app under the game’s cursor | Composite the app between the game’s other ink layers and its cursor layer, so the game’s cursor is drawn on top by the game | The real cursor, perfect | Means hooking the game’s UI render order. Research only, and likely too deep |
Input
All of this applies only to an app that asks for input. An app that asks for none (a holocall, a video, an effect) takes nothing from the game, wherever it shows.
| While | Mouse movement | Buttons and wheel | Keys |
|---|---|---|---|
| The cursor is over the app’s opaque pixels (over a game screen) | To the game (so its cursor keeps moving) and to the page | To the page only. The game must not get the click | To the game, unless the page has a focused text field or asked for keys (as Keyboard Lock does today) |
| The cursor is outside the app | To the game | To the game | To the game |
| An app shows in the world | To the game (the camera, as always) | To the game, unless the app maps them | The app’s mapped keys and controller buttons to the page and not to the game; every other key to the game. Its close key (Esc or the one that opened it) hides it |
| An app has paused the game | To the page only (the cursor inside it) | To the page only | To the page only, except Esc, which closes the app (or asks it to) and resumes the game |
In the world, the mapped inputs should behave like the game’s own contextual UI: while the quickhack wheel or an interaction prompt shows, its keys do its job and the rest of the game goes on. Which keys an app may take, and what happens when one is also a game action (F is Interact, R is Reload), is S3’s question.
Splitting one mouse input into “movement to the game, buttons not” is new. Interactive mode blocks everything. If the game reads buttons and movement from the same raw input packets, the plugin has to change the packet (clear its buttons) rather than drop it (S2).
The look
| Part | How |
|---|---|
| Colors, text sizes, weights | From the game look’s table (main_colors.inkstyle), already in the ink API, made into CSS for the UI kit’s game theme (the UI kit’s game look was planned beside I4 in docs/ink.md) |
| Fonts | The game’s fonts cannot ship with REDnode. Read them from the player’s game files at first use (through REDbridge) and give them to the page as a local font (unverified: the game’s font resources and whether they convert) |
| Frames, icons, textures | From the player’s game the same way (REDbridge’s texture_to_png), kept in a cache in the player’s data folder, never in a package or a release |
| Ink markup in HTML | A renderer that draws an .ink.html tree as HTML elements with the game look, so one markup file gives an ink screen or a semi-native page. The docs simulation already draws ink trees in HTML (docs/assets/examples/sim/runner.js), which is a start |
| Scale | The game scales its UI to the screen. The app scales with it (the reference size the overlay already uses) |
Spikes
Each spike is a test app and a small plugin change, run in game, before the build is planned in detail.
| Spike | Question | Decides |
|---|---|---|
| S1 The cursor over a game screen (first, deciding) | Over the inventory, with a test panel: where the game’s cursor is each frame, the copy’s offset and lag against the game’s (measured with MCP game_image while moving), the game cursor’s contexts (default, hover, click), hiding and showing it, reading its images through REDbridge |
A, B or neither. If neither, semi-native apps over game screens keep REDnode’s own cursor and an “enter” gesture, which loses the main point: the owner and Claude decide then whether to go on |
| S2 Clicks to the app, movement to the game | Can the plugin let the game’s cursor keep moving while the app takes the buttons and wheel? How does the game read the mouse in menus (raw input messages, a buffer, window messages)? Do game widgets under the app react? | The input design. If the split fails, the fallback is to stop the game’s cursor over the app and move the copy from raw input (B with REDnode’s own movement) |
| S3 Mapped inputs in the world | Show a test app on a key, then give it a few keys while it shows: can the plugin take those keys from the game and let every other one through (it already takes F10)? What about a key that is also a game action? Controller buttons: the plugin does not read the controller today, so how does the game read it (XInput or another API), and can a button be taken from the game the same way? Or is it cleaner to go through the game’s own input actions and contexts, as the quickhack wheel does (Codeware’s input callbacks, unverified)? | How an app in the world answers keys and buttons without breaking the game’s own |
| S4 Listening on a game button | Register a REDnodeInkListener on a game widget found with ink.at or ink.read (a button in the crafting menu), and hear its clicks. Find it again after the menu rebuilds |
Whether “show on a game button’s click” needs no redscript from the modder |
| S6 Pause with the cursor | From the world, a test app pauses the game and takes all input: P1 (the time system’s pause and interactive mode’s input for one app) against P2 (an empty game screen). Does the world stop fully (NPCs, cars, timers, sounds)? Can the player save, or open the pause menu, while it shows? Does the game resume cleanly on close, on a crash of the app, and when the package stops? | Which way paused apps go. P1 needs no unverified game entry, so it is the likely first try |
| S5 The game’s font and textures (can wait for the build) | Read the game’s font and a few frames and icons through REDbridge into the cache, and draw a game button in HTML beside the game’s own | Whether the look can be exact, or close |
Plan
Proposed phases, each tested in game before the next:
| Phase | What | Done when |
|---|---|---|
| SN0 Spikes | S1, then S2 to S4 and S6 (S5 can come with SN2) | The cursor way is chosen, or the owner decides the idea changes |
| SN1 Show and display | "kind": "native", app.show()/app.hide(), showing on menus and game states, in the Mod Manager. No input yet |
A holocall-style test app shows on a call and on a menu opening, with no F10 |
| SN2 The look | The UI kit’s game theme, the game’s font and textures from the player’s game, .ink.html drawn as HTML |
A game button in HTML next to the game’s own looks the same |
| SN3 The cursor over game screens | The chosen cursor way and the input split | Over the crafting menu, the cursor crosses into a test panel, clicks it, and leaves, with no seam and no click reaching the game |
| SN4 Mapped inputs in the world and game triggers | S3’s way (an app’s own key to show it, its mapped keys and controller buttons while it shows), and showing on a game button’s click (S4) or a mod’s redscript | A mini-game in the world shows on its key, plays with keys and a controller while the rest of the game goes on, and closes; a crafting-menu button shows an app |
| SN4b Paused apps | S6’s way: app.show({ pause: true }) (proposed), the cursor inside the app, all input to it, the game resumed on close, crash or stop |
A mouse mini-game opened from the world pauses the game, plays, and gives the game back as it was |
| SN5 The Netrunner bench sample | A sample built on all of it for EDGEhack’s add-on (if the owner still wants it in native ink, a semi-native version as a second sample) | Docs page, examples, release |
Decided with the owner
Agreed on 2026-11-12, every recommendation as drafted:
| Question | Decision |
|---|---|
| While F10’s interactive mode is on, are semi-native apps shown? | Yes, under the overlay’s windows, and not clickable then (the overlay owns the cursor in interactive mode) |
| Does F10’s hidden mode hide them? | Yes, as it hides pins: the player’s one switch to clear the screen of REDnode |
| Do they show in photo mode and scenes? | Hidden by default, as HUD widgets are, with hideWith to change it |
| Controller | In the world, in scope with S3 (mapped buttons). On game screens, after the mouse works: the game moves its cursor with the stick in menus, so A may carry over (unverified) |
| A cursor in the world | None while the game runs, as in the game (decided with the owner on 2026-11-12). An app that needs one pauses the game world (nothing moves, no menu opens) and shows the game’s cursor inside itself, with full input (added by the owner the same day), opens a game screen that has one, or is an F10 window |
| The kind’s name | "kind": "native" |
| Can a semi-native app be dragged or resized? | No title bar. Only if the app moves itself (as fill pages do with rn-window) |
| Permission | One new switch, native, since an app that takes clicks from the game’s own screens should be the player’s choice |