Sylveon 2026-03-10 04:45
NanoSys is my Operating system in LowRes NX and I need some people to help me develop the operating system, right now you probably don’t have to do anything. But when I finish developing the custom CPU, you can start making what part you want :3
Here’s the description of NanoSys:
Welcome to NanoSys, a Actual operating system made for a Emulated CPU programmed in BASIC.
The Operating system uses a Custom written CPU called the NX dual-Core advanced, with 2cores, uses my Custom RISC instruction set called UFPE64 (Ultra Fast Program Execution) and is a 64 big argtecture.
Feel free to use the raw CPU code for any other programs, like a Virtual Microcontroller. If you do Credit my Youtube username (@SylveonCoder67) and put the "REM NX DUAL CORE CPU BY SYLVEON (MADE IN 2026)"
This OS actually runs on a Virtual CPU, not stimulated from LowRes NX Coder, that means there is a Virtual Storage device, BIOS system, and RAM, and also I/O ports.
Inputs Devices such as keyboards (with LowRes NX’s keyboard) and Touchscreen are ran by a standard function in LowRes NX that runs every VBL interrupt, these functions (named "KBTS" and "TSTS") Translate ether Touchscreen Or Keyboard into the I2C ports that the CPU can read.
This program Standardly comes with “NanoSys” and with a Graphical Useri interface program named “NanoUI”, Feel free to modify any data on the Boot Medium and BIOS (all areas include GUI,Kernel,Bootloader,Drivers,AI accelerator,BOOTROM,BIOS,RootFS,MemoryFS). Credit me for any changes.
NanoSys comes with a Powerful kernel based of the Linux kernel, they both support packages, both use daemons, and *roughly* the same RootFS structure, and includes a few Drivers for core functionality like Mouse, Keyboard, Display, Graphics, Chiptune Audio. These Drivers have more elevated privileges and live in "/bin/drv" All the executables in the file path force-start before UI startup
NanoSys Kernel Can load binaries in .exec (which stands for Executable) and contains a few chunks for Metadata, metadata contains the Name of the program, 16x16 Icon, Allow Window Resize bit, BarSizeType bit.
BootChain: BOOTROM ==> BIOS ==> Bootloader ==> Kernel ==> NanoSysSetup ==> NanoSys ==> NanoUI ==> Program
Screen has 4 shades of monochrome to draw with, you have an 160x128 Canvas, White, Light Grey, Dark Grey, Black. When screen/Framebuffer is blank, Screen Remains white.
System standard comes with these specs: 256KB System RAM, VRAM 16MB, Storage of 256MB, System uses 18.9MB with no extra programs installed.
Cool Features of the NanoSys Kernel:
- AI accelerator in Kernel
- A few Pre-installed applications
- And a compiler
- Command line tool for full RootFS R/W access
- Game mode (increases efficiency and speed)
- Multi-Tasking window system
- Mount points for external storage devices (lives in "/mp")
- Export between your actual tools and LowRes NX as common formats
- Decompile tool in CMD (called “exectools d [PROGRAM BINARY PATH]”)
- Complex 3D Functions
All files in Root Directory and what’s In them:
/USR
/BIN
/MP
/APL
/SRC
/BOOT
In /BIN;
/DRV
/EXEC
In /SRC;
/DRIVERS
/PIA
/GUI
/KRNL
/BOOTLOAD
/ETC
in /MP;
/FILE?
in /APL;
PasswordLists.txt
UsernameLists.txt
PINlists.txt
UserPFP.bin
DefualtPFP.bin
In /USR;
/Downloads
/Documents
/ProgramData
Welcome.txt
In /BOOT:
BOOTLOADERIMG.img
KRNLIMG.img
SYSSTRTS.bash
All files on disk:
MouseDriver.exec
KeyboardDriver.exec
ChiptuneDriver.exec
DisplayDriver.exec
I2CdiskDriver.exec
BOOTLOADERIMG.img
KRNLIMG.IMG
PasswordLists.txt
UsernameLists.txt
PINlists.txt
UserPFP.bin
DefualtPFP.bin
LowRes Draw.exec
Alight motion.exec
Space Invaders.exec
NanoCompiler.exec
Welcome.txt
CMD.exec
SYSSTRTS.bash
startsystem.exec
shutdown.exec
nano_ui_v1.exec
passcrack.bash
fileedit.bash
pkg.exec
PFP makes.exec
systemfont0.font
systemfont1.font
menlo16x16.font
chalkboard16x16.font
systemsoundfont0.ct
systemsoundfont1.ct
sytemsoundfont_complex.ct
MicroSoftGS.ct
ConvertPNG.exec
ConvertWAV.exec
ConvertMIDI.exec
Nano Image Viewer.exec
Nano Audio player.exec
Nano Binary Inspection.exec
Nano PDF reader.exec
AI summary.exec
AI CommandBot.exec
Nano AI smartness.exec
AI_Restrictions.txt
And then Heres the (current/unfinished) progress for the custom cpu:
UFPE64:
- contains 32 64-bit GPRS (General purpose registers)
- Contains 16 20-bit GPRS
- Contains 16 32-bit GPRS
- Contains 16 16-bit GPRS
- Contains 16 8-bit GPRS
- contains 64 1-bit General purpose flags
- Contains 512 64-bit Variables via a built-in memory chip
- contains 8 I2C ports.
- Contains 16 GPIO pins
- Contains 4 PWM pins
- Audio Processor built inside chip
- contains 64-bit ALU.
REGISTERS:
MRA:
Register ID: 0001 (1)
Math Register A, 64-bit Floating point Input A for ALU.
MRB:
Register ID: 0010 (2)
Math Register B, 64-bit Floating point Input B for ALU.
MCA:
Register ID: 0011 (3)
Math Calculation, Determines what math to use, 8-bit, no floating point:
MCA=0; Addition
MCA=1; Subtraction
MCA=2; Multiplication
MCA=3; Division
MCA=4; Modulation
MCA=5; Removes Floating point, No MRB register is needed.
MOU:
Register ID: 0100 (4)
ALU output 64-bit floating point.
Afish
ASSEMBLY COMMANDS;
NOP:
Command Parameters: NOP
Command ID: 00000000
No Operation
HLT:
Command Parameters: HLT
Command ID: 00000110
Halts the execution of the current running core
ALUE:
Command Parameters: ALUE
Command ID: 00000001
Activates a Transistor that makes the ALU do its logic, instantly stops calculating afterwards
MOV64:
Command Parameters: MOV64 [register_id],[value]
Command ID: 00000010
Writes a 64 bit Floating point value into a 64-bit only register
MOV20:
Command Parameters: MOV20 [register_id],[value]
Command ID: 00000011
Writes a 20-bit Floating point value into a 20-bit register
MOV16:
Command Parameters: MOV16 [register_id],[value]
Command ID: 00000100
Writes a 16 bit value (No Floating point) into a 16-bit register
MOV8:
Command Parameters: MOV8 [register_id],[value]
Command ID: 00000101
Writes an 8 bit value (No Floating point) into a 8-bit register
FUNC:
Command Parameters: FUNC [identifier],[parameters_num],[has_parameters]
Command ID: 00000111
Defines the start of a Function. All code after this line until “EFUNC” is part of the Function
SWP:
Command Parameters: SWP [register0],[register1]
Command ID: 00001000
Swaps the value in register 0 to register 1, and register 1 data to register 0. Floating-point or bit amount doesn’t matter.
PSH:
Command Parameters: PSH [register0],[register1]
Command ID: 00001001
Pushes the data from Register 0 into Register 1, Floating point or bit format doesn’t matter.
JMP:
Command Parameters: JMP [command]
Command ID: 00001010
Jumps to the program execution Command ‘command’.
EFUNC:
Command Parameters: EFUNC [identifier]
Command ID: 00001011
Defines the End of the function code.
MEMW8:
Command Parameters: MEMW8 [bit],[value]
Command ID: 00001100
Writes an 8-bit value to Memory starting at a bit.
MEMR8:
Command Parameters: MEMR8 [bit],[register]
Command ID: 00001101
Reads an 8-bit value from a bit in memory, and loads it into an 8-bit register
20BIT FLOATING POINT SYSTEM:
Bit number Purpose Example
0 Has Floating Point 1
1 Floating point bit 0 0
2 Floating point bit 1 0
3 Floating point bit 2 0
4 Floating point bit 3 0
5 Floating point bit 4 0
6 Floating point bit 5 0
7 Floating point bit 6 1
8 Floating point bit 7 1
9 NUMERICAL BIT 0 0
10 NUMERICAL BIT 1 0
11 NUMERICAL BIT 2 0
12 NUMERICAL BIT 3 0
13 NUMERICAL BIT 4 0
14 NUMERICAL BIT 5 1
15 NUMERICAL BIT 6 0
16 NUMERICAL BIT 7 1
17 0
18 0
19 Negative bit 1
64BIT FLOATING POINT SYSTEM:
Example Output: -5.3
Bit Number Purpose Example
0 Has Floating point 1
1 Floating point bit 0 1
2 Floating point bit 1 1
3 Floating point bit 2 0
4 Floating point bit 3 0
5 Floating point bit 4 0
6 Floating point bit 5 0
7 Floating point bit 6 0
8 Floating point bit 7 0
9 Floating point bit 8 0
10 Floating point bit 9 0
11 Floating point bit 10 0
12 Floating point bit 11 0
13 Floating point bit 12 0
14 Floating point bit 13 0
15 Floating point bit 14 0
16 Floating point bit 15 0
17 0
18 NUMERICAL BIT 0 1
19 NUMERICAL BIT 1 0
20 NUMERICAL BIT 2 1
21 NUMERICAL BIT 3 0
22 NUMERICAL BIT 4 0
23 NUMERICAL BIT 5 0
24 NUMERICAL BIT 6 0
25 NUMERICAL BIT 7 0
26 NUMERICAL BIT 8 0
27 NUMERICAL BIT 9 0
28 NUMERICAL BIT 10 0
29 NUMERICAL BIT 11 0
30 NUMERICAL BIT 12 0
31 NUMERICAL BIT 13 0
32 NUMERICAL BIT 14 0
33 NUMERICAL BIT 15 0
34 NUMERICAL BIT 16 0
35 NUMERICAL BIT 17 0
36 NUMERICAL BIT 18 0
37 NUMERICAL BIT 19 0
38 NUMERICAL BIT 20 0
39 NUMERICAL BIT 21 0
40 NUMERICAL BIT 22 0
41 NUMERICAL BIT 23 0
42 NUMERICAL BIT 24 0
43 NUMERICAL BIT 25 0
44 NUMERICAL BIT 26 0
45 NUMERICAL BIT 27 0
46 NUMERICAL BIT 28 0
47 NUMERICAL BIT 29 0
48 NUMERICAL BIT 30 0
49 NUMERICAL BIT 31 0
50 0
51 0
52 0
53 0
54 0
55 0
56 0
57 0
58 0
59 0
60 0
61 0
62 0
63 Negative bit 1
moechofe 2026-03-10 09:07
So you want to simulate an operating system that runs on a simulated CPU that runs on a fantasy console?
wryhode 2026-03-10 10:57
this is very ambitious, good luck. maybe start by implementing an existing architecture to get familiar with the limitations
moechofe 2026-03-10 12:47
What rings a bell for me is this: an OS is supposed to access user content. What kind of content? It looks like this project can act as an editor (`FILES` command), and users will be able to run OS "software" on the virtual files of their programs.
Sylveon 2026-03-10 12:50
@moechofe it’s more like an emulated CPU (also, you are correct.) here’s an example assembly program that basically does this (And also the reason why I wouldn’t develop the OS for LowRes NX’s Virtual cpu, because it doesn’t have the ability to write/read raw lines of code on the disk.)
CALL MATH(4,4)
SUB MATH(A,B)
OUTPUT=A+B
END SUB
JMP 6
FUNR 1
PAR64 0,4
PAR64 1,4
FTRG 1
HLT
FUNC 1,1,1
LFPR 0,64GPR1
LFPR 1,64GPR2
PSH 64GPR1,MRA
PSH 64GPR2,MRB
MOV8 MCA,0
ALUE
MOV64 MRA,0
MOV64 MRB,0
MOV64 64GPR1,0
MOV64 64GPR2,0
SWD 8GPR1,MOU
EFUNC 1
JMP 1
HLT
Sylveon 2026-03-10 12:54
@moechofe the “user-content” it can do is run pre-compiled games (or your own programmed and compiled ones) and im also thinking of using FILE 14 so you can export/input files to and from NanoSys (like this would be useful to use the AI accelerator to turn a Compressed MP3 into Chiptune, etc.)
moechofe 2026-03-10 12:56
@Sylveon, so you'll need to create an interpreter inside an interpreter https://craftinginterpreters.com/
Get ready to encounter slowness.
moechofe 2026-03-10 12:57 (Edited)
Oh wait, if it's "compiled", now you'll need a virtual machine, that run inside an interpreter.
Sylveon 2026-03-10 13:07
@moechofe I don’t really care that much about slowness, I just want to see how far we can push LowRes NX. Also. I already have a Virtual Machine system layer out in my head. Also, the code interpreter might actually be pretty small since .exec files are Raw Binaries that the CPU executes. The Kernel has the functions for the heavy work.
Software Center 2026-03-10 21:18
This. Hurts. My. Brain.
Raichu 2026-03-14 13:02
i’ll do- oh god. oh. god. WHAT. THE. F- yeah i feel like it’s a good idea to go back to coding PPGW.