1/24/2026 - First steps and PCBs

Hi! This is the first journal entry of the Rian's MicroComputer.
This is my first hardware project, and it was in these 3 weeks that I learned how to use KiCad and 3D rendering (thats why it has 12h only for pcbs and 22h only for 3D rendering from scratch using pixels, no 3D lib behind it)

03/01 to 05/01 - The idea: 1h hour

From 3rd January to 5th January, I had an idea: what if I made my own computer?

I started studying my idea, and tried to create the first image on my head. I wanted it to be like a Nintendo 3DS - portable, foldable, small, but instead of an analog stick, it would have a keyboard.

I knew that I would need a screen and a processor, but which?
For the processor, I thought about an Arduino micro controller, and for the screen, something that communicates with it using GPIO pins: TFT Screens! So I bought one 3.5" screen at Aliexpress. But when I tested the arduino I already had with the screen, it was SO SLOW. Then, I thought: Why not a Raspberry PI? And the answer is: I want to make the Operational System too! And it is so complicated to do with a real micro computer. So, lets simplify things: I found an Arduino, but more powerful, stronger and smaller: ESP32-S3.
With the ESP32-S3 I found, I would have the great amount of 16mb flash, 8mb RAM, and 240mhz (While arduino only had 2mb flash, a few kb of RAM and 16mhz).
I bought the ESP32 and tested it with the screen, and this is what I realised...

06/01 to 18/01 Screen Testing:

Breaking my patience with drivers and display (5h)

During these days, I tested the 3.5" TFT screen, with some 3D on it, SD card tests and ESP32 memory using LovyanGFX.

The main problem I had with the screen, was that I was trying to follow the manufacturer manual, but it suggested the library TFTeSPI, and it didn't matter how much I tried, it didn't work. So, I tried some different libraries, like ArduinoST76.., and the one that finally worked: LovyanGFX!

At the start, LovyanGFX didn't work. The pins were a little off (I connected some pins wrong and also configured the library wrong. But, I made it work! And here are some tests I made:

Simple Tests: 3h

Images covering the entire screen at great 17.1fps. First, created a frame to store every pixel and then blit the entire frame directly to the screen to increase performance. Then, created a struct called Sprite that creates and loads a sprite. Its Draw function draws the sprite (With transparency) to the frame. It loads .png from the SD Card.

3D cubes rendering using the same principle of the frame, but drawing and calculating each pixel separately. Calculates the camera perspective and each cube's face and vertices position and draw each pixel.

Pre made test for LovyanGFX of its drawing functions

Complex 3D models rendering CPU bound from scratch (22h disconsidered from counting!)

Here I tested the screen making from scratch a 3D models renderer using only the CPU and functions from LovyanGFX.
To do that, I thought I could work with the .glb. But I realised that the ESP32 wouldn't be able to read it because it would be so slow to read and interpret the glb data, and it would be a binary file (more difficult to make the interpreter), so I created a script that converts a .glb model to a cpp header with the texture and vertices. After that, I created a program in ArduinoIDE (the program I'll be using to make everything) that imports some models in RAW .h (Lists of meshes and textures with int and float values) and calculates the perspective, rotation, position, scale and the colour of each pixel in the screen. But it turned out that the colours were messed up and inverted:

Even if I inverted the LovyanGFX colours setting, it wouldn't work. After, I realised that my colour converter from the normal colours to RGB565 colours was wrong.
When I changed the orders: Perfect pixels and render.

The code is avaliable on github at tests/3dmodels/3dmodels.ino

19/01 to 24/01 - First PCBs: 12h

Then, within this week (From 19/01 to 24/01) I've transformed what I imagined and tested on the protoboard into a real product. So, I started with the PCB, the most difficult part for me. I've made so far the matricial keyboard pcb - This was a really challenge, because I got to use as less amount of GPIO Pins as possible, so I thought about the screen: We use X and Y to represent pixels- (8h. From 19/01 to 22/01 The keyboard organized in matrices. so, every key has your own X and Y position, and when combined, can verify the key pressed), and finishing the main pcb (4h. This is going to connect all components. The esp32 to the screen (using flat cable socket) and the keyboard). The keyboard PCB will be attatched to the main PCB using pin headers and sockets.

I started by placing components based on my protoboard layout, then routed the tracks manually copying the connections I had tested. I used KiCad for everything — first the footprint placement, then the copper tracks, and finally the schematic copying the tracks from the PCB.

This was the most difficult part, because I had to learn how to use KiCad. So, the PCB may have bad routings and thats why it took so long. But, at the end, I learned how to use KiCad and create my own PCBs.

Therefore, I've been facing a problem with powering. I really don't know how I'm going to power up everything within a small case. I thought first some AA rechargeable 3.7v 3000mah bateries, but it has a higher voltage than the allowed, and plus: I would have only some minutes of fun. I'm browsing a module that converts 7.6v to 3.3 automatically or a battery case that outputs the same as my computer with cable USB C.

References:
LovyanGFX Graphics Lib Docs I created: docs
TFT Screen Pins: pins and instructions
TFT Screen datasheet: 3.5inchSPIModuleMSP3525MSP3526UserManual_EN
ESP32 S3 datasheet: esp32-s3datasheeten
KiCad tutorial: https://www.youtube.com/watch?v=mmhareh99P8
Blender tutorial: https://www.youtube.com/watch?v=peSv5IT5Ve4
LovyanGFX tutorial: https://www.youtube.com/watch?v=IPCvQ4o_WP8

1/25/2026 - Design

Today I've made the computer design using Blender. Since this was my first time working on Blender, it was pretty hard to get the shortcuts and become fast on it.
The most difficult part was making the upper lid, because it needs to have some space on the hinge to turn. The 3D printer makes everything more fat (3.7h)

Also discovered how I will power it up, charge and power down.

So, for powering I will use a 18650 USB, which transforms an AA battery into a Power Bank. The output is 5V 2A, which seems ok to the setup. I decided to do so, because I can connect an USB-C cable from the output directly to the ESP32, and in my tests, 5V directly from a battery didn't power up everything and the screen backlight was so weak.

To charging up, I will put a USB-C male connected to the input of the battery and connect it to a converter USB-C male to USB-A female. So, there will be a USB-A port ready to plug in and charge everything.

The system will never turn down completely, because this battery holder I ordered doesn't have a switch and I wouldn't be able to cut the powering of the usb-c cable (at least for now).

So, there will be a button in the system to turn off, which will activate the esp32 deep hybernation mode and turn off the screen. Then, when clicking any key on the keyboard's row 5 (tgv row), it will restart and exit hybernation. The only way to turn it completely down, would be letting it run out od battery.

I also made some modifications on the PCB (Cut a hole on the PCB to pass the USB C to charge the ESP32, removed the battery support and added the flat cable socket for screen and reconected tracks to the socket) (0.3h).

1/26/2026 - Design Edited and More Powering Tests

Today I've made some changes on the design. Added a USB port, added the esp32 on the board, modified the hinges to be more tight to the hinge "connector).

I also tested the light sleep and tft sleep functions, reset using software and googled about power consumption. Everything now is schematized.

I made a chart about the powering:

Powering looks decent and so the battery duration.

1/30/2026 - Tracked Prices

During these 2 days of work, I've made some work on the PCB -fixed the tracks that were not straighttortas and revised all the tracks- and routed where I should manufacture them.

I started calling a lot of local factories, but they were so expensive.

So, I will manufacture everything with JLCPCB. I've added the general board to my cart, but 1 component for the keyboard were in inventory shortage, so I pre-ordered by 5ish dollars the Pin Header I need.

The problem when quoting on JLCPCB was that my BOM was really messed up, and I had to redo it using the JLCPCB pattern. This took me a lot of time.
And the other problem was that I had to search for the components, and it took so much time. The time consuming one were the pin headers and pin sockets. Some were not avaliable, so I had to make a pre-order.

Everything will cost approximately 700 reais (5 general boards and 5 keyboards. 2 assembled).

Plus the 3D print for the case will cost ~18 dollars (Two PCs) (JayG from HackClub Printing Stuff).

The screen: ~140 reais (paid by me)
The ESP32: ~90 reais (paid by me)

1/31/2026 - First Firmware steps and OS

Today, I've researched some ways to run the Firmware, multitasking and apps.

So, the problem was about the apps: How the system would run multiple apps with open software and that wouldn't depend on just the base firmware and save states, I mean, if I put every app inside the firmware (.ino), the apps wouldn't be updateable easily. Everything would be linked in a way that: If a software breaks, all the system breaks, and I would have to compile the ENTIRE SKETCH again and again.

To solve it, I decided to run a Lua interpreter within Esp32.

This will allow me to create: The bios, firmware, OS and apps runner separately from the apps themselves.

The firmware and OS will be created apart in a .ino sketch, and the apps will have their own folder inside the SD Card and their own folder structure. Generally containing fonts, images, config json, .lua scripting files.

The OS job will only be read the lua script and interpret it.

There will be a ton of external functions which could be used to create the apps, such as: File functions, Drawing, Math, OS management (Configs, restart, shutdown, close app, etc). The definitions and instructions controlled and set by the C++ sketch (Firmware).

This is the base of the firmware. So far it has only the screen and sd init, interpreter starter and one external function: endProgram() to end the VM.

2/3/2026 - Case Fixes and More PCB Quotings

During these days, I've added screw holes to my case, and discovered that the JLCPCB don't have the part I need (Pinheader Pitch 2.54mm 8mm height), so I'm going to buy this part from AliExpress, and solder it by myself with a borrowed Solding Station from the theater lights guy.

I also converted the .blend into a .step file. It had a some of errors and convertion isn't precise, but ok. It is 4gb...

In addition, to the 3D prints, I found a guy that prints inside Blueprint (I forgot the program name). And he just ask for the shipping price and fillament.

2/6/2026 - README, Github, Name and Notes for the reviewer

During these 2 days, I've been writing the README and configuring the Github Repo.

The README is already avaliable on Github.

I also changed the project's name, to be more, shocking...

Added some notes for the reviewer about why 2 computers and the lack of a correct .step (Current is 4gb).

Furthermore, I made the wiring diagram for parts out of the pcb.

2/7/2026 - OS Design

In an hour, I made the OS design and pages.
I want the design to be a little Linux Like, kinda cozy, and easy to use. It will work with an arrow system. With WASD you control where your "cursor" is, like game consoles.

Starting:

Login:

Home Page:

2/10/2026 - Stickers and Powering Issues

Today I've finally recieved my stickers, and they are so cute!

Loved the processor one!!

To frustrate a little bit the day, though, the battery holders didn't work. It just doesn't charge and neither transfers the electricity to the esp32.
To solve that, I will use a power bank that must have 2 USBS (one for charging, and one for output) and a powering on/off button.
I will use a power bank module to prioritize safety, reduce development risk, and keep the project scope focused on PCB design, firmware, and system integration. The power bank provides built-in protection and regulated output.

2/12/2026 - Powering

Today I finally found the perfect powering system to this project: Futurizta Power Bank 5000mah Mini.

This power bank has 5000mah (Battery would last so longer than if I've bought a AAA battery), so it would last 27h. And with the WIFI on: 14.5h.

In addition, it is so tiny being only 7.5x3.5x2cm, fitting perfectly inside the computer.

This project is gonna be really fat. The lower part will be 4cm tall.

So, the powering chart is like this now:

2/27/2026 - System's Kernel and Tests

During 4 days (From 4 days ago to today), I've been developing the OS Kernel.
I've spent great 12 hours developing the kernel main functions and folder structure.

The kernel now starts screen, starts sd module, loads boot configs, creates screen frame, loads general configs, synchronize time using wifi to obtain real life time and set it to the RTC and then turns off wifi to save energy, loads user, starts first lua vm (OS Graphic Interface).

OS functions:
DisplayClearScreen, DisplayUpdateScreen, OSGetFreeMemory, OSGetMemorySize, OSGetFreeHeapMemory, OSGetHeapMemorySize, OSGetCPUTemperature, OSGetTime:toString("%d/%m/%Y - %H:%M:%S"), OSGetLuaVMHeapMemoryUsage, OSGetUserUsername, OS_GetUserPassword

Furthermore, I've made the Sprite exported structure and exported lua variable type and so with Fonts.
This is a simple example lua code of how the system is working:

local user_login_bg = Sprite("/sys/img/user_login_bg.png", 480, 320)
local gothambold_font = Font("/sys/fonts/Gotham Bold.bin")

-- FPS
local fps = 0
local frameCount = 0
local lastTime = os.clock()

function loop()
   while true do
      local currentTime = os.clock()
      frameCount = frameCount + 1

      -- Atualiza FPS a cada 1 segundo
      if currentTime - lastTime >= 1 then
         collectgarbage("collect")
         fps = frameCount
         frameCount = 0
         lastTime = currentTime
         --print("FPS:", fps)
         --print("Temperature: ", OS_GetCPUTemperature())
         --print("Free Memory: ", OS_GetFreeHeapMemory())
         --print("Memory Size: ", OS_GetMemorySize())
         --print("RTC: ", OS_GetTime():toString("%d/%m/%Y - %H:%M:%S"))
         --print("Lua Heap Memory Usage: ", OS_GetLuaVMHeapMemoryUsage())
      end

      Display_ClearScreen()

      user_login_bg:draw(0, 0)
      gothambold_font:drawString(OS_GetUserUsername(), 148, 150, 20, 255, 255, 255)

      Display_UpdateScreen()
   end
end

function start()
   loop()
end

start()
endProgram()

Images are always in .png, supported transparency, and fonts are always in .bin.
The fonts are converted from ttf to binary files using a python script avaliable on github.

The most difficult part was the Lua VM memory management: In the beginning, there was a big memory leak in LUA VMs. The solution was to call every second collectgarbage("collect").
And also: the luaHeapUsed variable was being miscounted, causing a memory leak.

Here is the OS booting and start page: