Skip to content

Development roadmap

Reviewed 18 November 2026. A fresh SD install reached Pocket on the third tablet. Physical tests also covered lock/unlock on slot B, a six-bank radio backup and bidirectional LoRa messaging. The checks below cover the remaining cases. Hardware results and limitations.

Current tablet priorities

Priority Work Acceptance check
Display recovery Make lock and unlock reliable while Pocket owns the framebuffer. Slide twice under GPU load; verify input, picture and lamp return without restarting. Repeat on battery and charger.
Fresh install Include the companion picker, safe glyph rendering, and revised contact navigation in a clean image. Boot both slots, test GUI and TUI, update and roll back while retaining user data.
Text and navigation Expand the shipped GUI font with licensed punctuation, accented names and symbols. Document emoji coverage and font asset size. Use accessible hardware keys and separate channels from contacts. Render multilingual contact fixtures with no crash, verify legibility and memory use, and page a large list with the slide-out keyboard and touch.
UV-PRO channel banks The full backup read all six banks and restored bank 0 and its settings. Reception paused during the sweep and reconnected after a delay. Check cancellation on hardware and confirm a valid incoming position reaches Station Map after reconnect.
Radio and mesh Test UV-PRO reconnect, hub selection, MeshCore pairing and Reticulum executor handoff. Verify the selected peer, sustained receive and reconnection after power loss.
Sensors and audio Verify ambient-light response, keyboard lighting, charge estimates, headset routing and per-app sound. Record physical observations alongside sensor and mixer state.
Performance and distribution Measure cold and warm map/terrain loads, Doom, input latency, and actual disk use for cached and clean builds. Publish repeatable timings and measured host storage requirements.

Current hardware and app support records the evidence behind these priorities.

These investigations concern future work. Each begins with evidence from the existing implementation and has a specific question to resolve.

Investigation Existing foundation Evidence needed before changing the design
Reduce window-movement cost Retained cell planes and damage tracking in the host. Measure which planes rebuild, how many cells are composed, and output bytes during a repeatable drag. Compare static and animated backgrounds.
Preserve responsive interaction under load Calibrated input, process acquisition, native buffering, and Touch lab. Correlate event timestamps, desktop dispatch, and visible response. Record connection state and background workload with the capture.
Extend direct pixel scenes Integrated native frontend, direct Room pixels, and ordered window overlays. Validate more apps, resource lifetime, and physical Nokia behavior while preserving terminal views.
Reduce idle work Shared owners, subscriptions, and change-driven rendering. Attribute CPU use to the desktop and each owner with Local-only and connected configurations.
Complete source lineage Kernel locks, component import records, licenses, and Git history. Record upstream path/revision, modifications, and supporting development records per component. Mark unresolved human/LLM attribution explicitly.
Run selected ARM Windows CE applications Native ARM execution and managed display handoff from the Symbian runtime. The authored fixture passed on the N810. Verify ordinal imports and the file and window services SpreadCE needs.

The architecture, rendering explanation, and touch-acquisition record describe the current foundations. The journal records the progression and its measured results.

Run selected Symbian games on Linux

The goal is to play selected older Symbian games on the N810 through a compatibility layer integrated with the Linux system. Each game's actual dependencies define the initial scope. Pocket supplies the surrounding desktop; the compatibility work supplies the executable and service behavior required by the chosen game.

Demonstrated graphics foundation

The MBX bring-up journal describes getting standard glxgears rendering through Mesa and X11. The following performance investigation records two physical-device runs at 30.78 and 30.63 completed GPU FPS after moving the gears' transformation and lighting onto the VGP. The driver build and test guide links the frozen implementation, build inputs, and regression tests.

Those results establish a hardware-accelerated graphics foundation for investigating game compatibility. Their measurements apply to the documented gears workload and presentation path. A game's executable loading, graphics calls, input, audio, and timing require their own evidence.

Progress recorded on 6–7 November 2026

Native ChessGenius execution reached a visible board and completed d2-d4 followed by the game's e7-e6 reply on the N810. That milestone used CPU softpipe rendering. Its later run reduced startup to the first partial UI and completed graphics teardown after a requested stop.

The subsequent GPU investigation has exact physical-device results for selected clear, retained-surface, scissor, and large-texture operations. ChessGenius and Snakes both execute native ARM code and reach GPU jobs. By 9 November ChessGenius reached its menus and board on the GPU, and Pocket could launch it and restore the desktop. Menu response averaged about 1.2 seconds. Sustained play and responsiveness remain open. Symbian application tests. The driver candidates and runtime have yet to become a public reproducible compatibility checkpoint.

Remaining compatibility work

Continue with the identified ChessGenius and Snakes targets, retaining their executable identities and dependencies in the test records. Hardware compatibility must be checked against that target: a shared CPU instruction set or related graphics processor provides useful overlap, while the software interfaces still determine what the executable expects.

Implement the interfaces needed to reach successive observable milestones. For asynchronous requests, document completion, cancellation, errors, and callback ordering as the game observes them. Choose Linux implementation mechanisms after establishing those requirements. Preserve the existing system architecture while supplying the behavior needed by the target application.

flowchart TB
    target["Select and identify one game"] --> dependencies["Inspect executable and dependencies"]
    dependencies --> load["Load executable and reach startup"]
    load --> graphics["Map required graphics interfaces"]
    mbx["Demonstrated MBX and Mesa checkpoint"] --> graphics
    graphics --> frame["Capture a correct game frame"]
    frame --> interaction["Verify controls, timing, and audio"]
    interaction --> play["Record a repeatable playable session"]

Record progress separately for executable startup, a correct rendered frame, working controls, working audio, and sustained play. Each result should identify the source revision, game version, hardware, configuration, and observed limitations. Publish technical findings and permitted captures with links to the corresponding implementation and tests. Keep unverified compatibility expectations in this roadmap until a reproducible result supports a journal entry.

Run selected ARM Windows CE applications on Linux

The 10 November design investigation led to a small ARM Windows CE 3 test program. On 11 November the experimental loader ran it on the N810, resolved two named imports, printed the expected result and exited successfully. The harness is still separate from the published source. SpreadCE imports functions by ordinal, which the loader cannot yet resolve. The next checks are a verified CE 3 export map, ordinal resolution and the file and window services needed to edit and reopen a sheet.

The memory model needs a guest VirtualAlloc and mapping manager for the 32 MB private-process layout, shared allocations, protection changes, and address collisions. The N810's 32-bit ARM kernel uses 4 KB pages; the CE KData and trap addresses in the upper address range cannot simply be mapped as Linux user pages. Identify the target program's actual KData, thread-local, and trap accesses before choosing direct shims, instruction handling, or controlled fault interception. Keep intentional guest traps distinct from genuine faults. Full structured exception handling belongs to the compatibility work for applications that require it.

Advance through separately checked milestones: loader and import resolution; native ARM execution with a small set of calls; files, handles, threads, and timers; a message loop and basic GDI window; then the first real application, SpreadCE. The locally supplied SpreadCE executable is a 5.9 MB ARM CE 3 PE with a preferred base of 0x10000, stripped relocations, an exception directory, and imports from COREDLL.dll, commctrl.dll, commdlg.dll, and WININET.dll. Its fixed base and broad UI imports make it a poor loader diagnostic, but its ordinary spreadsheet workflow gives a concrete application goal: open a blank sheet, edit a cell, save and reopen it, and exit cleanly. Check each stage on a host and on the N810 separately; only the small fixture has passed on the N810.

PocketDOS's ARM CAB is a later target: its DOS emulator adds work beyond CE. The BE-300 build is MIPS and needs a separate CPU path. A local 56 KB ARM CE 2.11 MPEG player is smaller than SpreadCE, but playback, sound, and the older CE profile make it a less useful first application test.

We'll publish runtime and harness source, not app binaries. Testers can get SpreadCE from Bye Design's version page (HPC 2000 ARM); the Entertainment Pack evaluation CD and Entertainment Pack 2 CD are other CE software sources. Check each program's CPU before testing it.

WCECL illustrates a replacement COREDLL, but targets x86 applications on desktop Windows and is archived. CERF and MAME are hardware-emulation references, not native ARM runtime bases. Review the exact revision and license before reusing any code. The next application-level result is SpreadCE’s edit and save workflow. A PocketDOS screen, working controls, and usable speed are later, independent results.

Recording follow-up: desktop previews and background clearing

The isolated laptop captures made on 6 November exposed two visible issues. Some Settings icons become question marks in the overview, and Station Map thumbnails can contain the header with an empty map area. Compare each miniature with its source cell plane, including half-block terrain and icon glyphs, and verify that previews update when asynchronous map work completes.

The background-off step in the overview tour leaves visible glyphs on desktop 3. Trace the toggle through background state, damage tracking and terminal output. Acceptance requires a cleared desktop after switching the background off, followed by a correctly redrawn effect when it is enabled again. These observations are from the local documentation checkpoint; implementation and device validation remain future work.

Map previews and selected-area downloads

The retained-map resize correction and selective elevation sampling are recorded in the 7 November journal entry. Further work is to measure cold preparation and refinement on the Nokia, choose a device detail budget, and inspect pan, zoom, clipping, and input under load.

Area selection currently uses the map build commands and saved configuration. An integrated area-and-layer download pane still needs progress reporting, cancellation, cache reuse, and a clear estimate of the requested data size. Fine elevation remains available to analysis while locally derived overviews serve display work.

Native graphical desktop and interactive scenes

The native Mac desktop runs the shared application registry and desktop model, consumes packed composition batches, and draws Surface Room directly at window pixel resolution. Target-range interaction adds movement, aiming, hit state, and reset. The later GPU provider has exact-output comparisons for windows, Flux, Flurry, Station Map, and terrain.

The next work follows the remaining boundaries in those tests:

  • Extend the integrated build checks with the remaining experimental exact-output comparisons. The platform inputs now build from a fresh checkout through the graphical frontend Makefile targets.
  • Bring the target-range acceptance checks into the integrated desktop, including capture release, focus loss, hits, reset, and restored graphics state.
  • Resolve the application-view notification warning seen at the end of the combined GPU run, then verify session save and restore.
  • Compare CPU and GPU paths with identical scene inputs, dimensions, quality, warmup, and frame counts. Include preparation, precision repairs, readback, composition, and presentation in the accounting.
  • Reduce copies and GPU readback where the platform permits, with image comparisons and buffer-lifetime checks before changing the default.
  • Validate direct scene pixels, transparency, and mixed GPU state on the physical N810. Ordinary desktop text now uses native C cell rasterization, with calibrated process-owned touch; GPU scene acceptance remains separate from that desktop baseline.

Moving projectiles would extend the current immediate ray-based target test with travel time and collision over simulation steps. That remains a possible scene extension, separate from the implemented hit/reset behavior.

N810 installation and application follow-up

Functional acceptance covers both the terminal desktop and native GUI, followed by physical MBX GPU checks. Track cold map preparation, retained map memory, Flux frame pacing and Doom responsiveness separately from correctness; record matched workloads before changing quality or rendering paths.

Measure peak disk usage separately for installing a prebuilt kit and building from source. Audit Docker layers, intermediate root filesystems and kit copies before revising the current free-space requirement. Card capacity must not require an equally large laptop image: persistent data occupies the remaining card partition and its filesystem grows on the tablet.