NYX

📓 devlog · 2026-09-08

• added shell module, implemented basic command parsing and execution flow, using a simple function pointer array for command dispatch
• fleshed out shell functionality, included support for built-in commands and input handling, ensuring proper memory allocation for command buffers
• tidied up shell code, removed redundant whitespace and improved consistency in formatting to enhance readability
• performed multiple cleanups, refactored shell initialization code for better modularity and maintainability
• wired up shell to the main application loop, ensuring proper integration and execution flow with other components
• addressed multiple whitespace issues across files, ensuring consistent coding standards throughout the project

📓 devlog · 2026-09-07

• implemented fs, focused on the core file system structure, ensuring proper data layout for efficient file access.
• fixed a typo in the shell, improving command parsing accuracy and preventing potential runtime errors.
• tidied shell code by removing unnecessary whitespace and organizing functions for better readability and maintenance.
• performed multiple formatting updates across various files to adhere to coding standards, ensuring uniformity in style.
• continued work in progress on shell functionality, refining command handling and improving control flow for user input.
• completed cleanup tasks to remove unused variables and redundant code, optimizing memory usage and enhancing performance.

📓 devlog · 2026-09-05

• added drivers for peripheral devices, ensuring proper initialization and configuration settings.
• implemented a basic shell structure, allowing for command processing and execution.
• performed multiple whitespace fixes across various files for improved readability and consistency.
• cleaned up existing code, removing unused variables and dead code to streamline execution paths.
• created a rough outline for the shell functionality, defining command handling and parsing logic.
• updated shell implementation to handle user inputs and provide feedback on command execution.
• added stubs for future shell commands, preparing for further functionality expansion.

📓 devlog · 2026-09-03

• added drivers for peripheral communication, structured to allow for easier integration with existing modules.
• fleshed out driver implementations, ensuring proper handling of initialization and resource allocation.
• started sketching a shell interface, focusing on command parsing and execution flow.
• performed multiple whitespace fixes across various files for improved readability and consistency.
• conducted cleanup of redundant code segments in the driver files, reducing overall complexity.
• wired up drivers to interact with the new shell, establishing a basic command execution pathway.
• implemented additional driver functionality to support expanded hardware features, enhancing overall system capability.

📓 devlog · 2026-09-02

• tidied up the main module, removed unused imports and improved code readability through consistent formatting.
• wired up the main module with initial control flow, ensuring proper function calls and data handling.
• added a preliminary structure for the main module, including stubs for future function implementations.
• started development on drivers, implementing basic functionality and ensuring proper interaction with the main module.
• fleshed out the drivers with additional features, focusing on data handling and performance.
• sketched out the shell interface for user interaction, laying groundwork for input handling and command processing.
• performed multiple whitespace fixes across various files to maintain code clarity and consistency.

📓 devlog · 2026-09-01

• added main module, defined basic structure and entry point for the application flow.
• cleaned up code formatting across multiple files, improved readability and maintained consistency.
• fleshed out main functionality, implemented key features and logic required for initial operation.
• performed multiple whitespace fixes, ensured compliance with style guide and improved diff clarity.
• started additional main implementations, focused on refining specific functions and control flow.
• tidied main module, reorganized code for better logical grouping and clarity, enhanced maintainability.
• conducted cleanup, removed unused variables and functions, streamlined overall codebase.

📓 devlog · 2026-08-31

• added main module, set up initial structure and entry points for control flow.
• wired up main, ensured proper integration with existing components.
• cleaned up codebase, removed unused variables and streamlined functions for better readability.
• tidied up main, focused on consistent naming conventions and indentation.
• addressed multiple whitespace issues, ensuring uniform formatting throughout the code.
• fleshed out main with additional functionality, enh

📓 devlog · 2026-08-29

• implemented main module, structured the control flow to handle various inputs and outputs efficiently.
• wired up main functionality, ensured integration with existing components while maintaining modularity.
• performed multiple whitespace fixes across the codebase to enhance readability and comply with formatting standards.
• cleaned up redundant code in main, improving maintainability without altering the core logic.
• fleshed out main, added necessary functions to support additional features and edge cases.
• tidied up main to simplify the execution path, reducing cognitive load for future development.
• formatted code consistently, aligning with project style guidelines for better collaboration.

📓 devlog · 2026-08-28

• cleaned up whitespace in several files to maintain code consistency and readability.
• implemented stub functions in module m8 to outline future functionality without full implementation.
• organized and tidied code in m8, removing unnecessary lines and improving structure.
• continued work in progress on module m8, addressing various incomplete sections.
• fleshed out details in module m8, adding logic to improve functionality and integration.
• added new features to m8, enhancing its capabilities based on recent requirements.
• performed additional cleanup in m8 to remove deprecated code and streamline performance.

📓 devlog · 2026-08-27

• cleaned up various sections of the codebase, focusing on removing redundant comments and unused variables for better readability.
• added module m7, defining its structure and initial state, laying groundwork for subsequent implementations.
• wired up m7 to existing systems, ensuring data flow and control paths are correctly established.
• fleshed out m7 with core functionality, implementing key methods and internal logic to meet specifications.
• began rough implementation of m9, setting up initial framework and placeholders for upcoming features.
• fixed typos in m9, correcting variable names and comments for clarity and consistency.
• implemented core functions for m9, following through on the designs sketched in earlier commits.

📓 devlog · 2026-08-26

• implemented module m2, focused on core functionality, ensured proper data handling and state management
• wired up module m2, established connections with existing components, validated data flow between modules
• started development on module m7, created initial stubs to define interface and behavior expectations
• fixed a bug in module m7 related to incorrect state transitions, improved control flow
• conducted cleanup across various modules, removed unused variables and optimized memory layout
• worked on ktest, tidied up existing tests, improved structure for better readability and maintainability
• performed whitespace fixes across multiple files to maintain consistency and adhere to coding standards

📓 devlog · 2026-08-25- worked on scheduling system, added preliminary structures for new scheduling algorithms while ensuring compatibility with existing code.- performed code tidying in the scheduling module, improving readability and reducing cyclomatic complexity.- implemented core functionality for module m5, focusing on resource allocation and control flow for task management.- fixed whitespace issues throughout the codebase, ensuring consistent formatting and adherence to style guidelines.- completed the implementation of module m5, integrating features from earlier sketches and ensuring edge cases are handled.- conducted cleanup on multiple modules, removing redundant code and ensuring proper memory allocation practices are followed.- added preliminary sketches for module m2, laying groundwork for future functionality and ensuring alignment with overall architecture.

📓 devlog · 2026-08-23- added ramfs module, implemented initial allocation and file structure layout for in-memory file system.- cleaned up whitespace and formatting across multiple files to improve readability and maintainability.- stubs created for m4 module, establishing the basic structure and placeholders for future development.- wired up ramfs to the existing system, ensuring proper integration with the kernel and other subsystems.- worked on m4 module, refining control flow and preparing it for handling input and output operations.- multiple sketches of ramfs and m4 completed, outlining potential features and behaviors for further implementation.- conducted overall cleanup of the codebase, addressing minor issues and ensuring consistent coding standards.

📓 devlog · 2026-08-23

• added ramfs module, implemented initial allocation and file structure layout for in-memory file system.
• cleaned up whitespace and formatting across multiple files to improve readability and maintainability.
• stubs created for m4 module, establishing the basic structure and placeholders for future development.
• wired up ramfs to the existing system, ensuring proper integration with the kernel and other subsystems.
• worked on m4 module, refining control flow and preparing it for handling input and output operations.
• multiple sketches of ramfs and m4 completed, outlining potential features and behaviors for further implementation.
• conducted overall cleanup of the codebase, addressing minor issues and ensuring consistent coding standards.

📓 devlog · 2026-08-22

• implemented ramfs, defined basic structure and operations for file handling and memory layout
• fleshed out ramfs, added functions for reading and writing files, ensuring proper memory allocation
• started ramfs, established initial setup for in-memory filesystem structure and controls
• cleaned up code across multiple files, removed unnecessary whitespace for better readability
• performed formatting adjustments, ensured consistent code style and indentation throughout the project
• worked on rough elf, iterated on the ELF parsing logic and data structures for improved parsing accuracy
• added additional cleanup commits for better organization and maintainability of the codebase

📓 devlog · 2026-08-19 - cleaned up ktest, removed unnecessary code and improved readability for better maintainability. - began outlining ktest structure, defined major test cases and expected outcomes to streamline future development. - fleshed out vfs, added initial functions for file handling and directory structure, focusing on memory layout. - implemented basic elf loading, structured code to handle ELF file format parsing and memory allocation. - performed multiple cleanups across modules, consolidated formatting and fixed whitespace issues to adhere to style guidelines. - initiated elf module, set up initial framework for ELF support including header parsing and section handling.

📓 devlog · 2026-08-17- implemented tar functionality, focusing on the compression algorithm and ensuring efficient file handling during archiving.- added multiple methods for extracting and listing files within the tar format, ensuring compatibility with various file types.- began work on the virtual file system (vfs), outlining the necessary data structures for managing file metadata and storage locations.- added initial stubs for vfs functions, setting up a foundation for future integration with the tar operations.- performed formatting changes across several files to improve code readability and maintain consistency in style.- addressed whitespace issues in the codebase to enhance clarity and adhere to coding standards.- continued development on vfs, sketching out control flow and interactions between the file system and tar operations.

• added module m6, structured to handle new data processing tasks with lower memory overhead.- wired up module m6, integrated it into the existing control flow to ensure correct data handling.- implemented core functionality for module m6, focusing on efficient allocation and deallocation.- wired up the hello module, ensuring it interfaces properly with other components.- implemented motd, providing a simple message on system start to enhance user experience.- worked on tar, stubbing out initial functionality while preparing for future enhancements.- performed cleanup across various modules, focusing on code readability and eliminating unused variables.

📓 devlog · 2026-08-14

• added initial sketches for ktest and pci modules, outlining the basic structure and intended functionality.
• conducted general cleanup across the repository, removing unused code and improving overall organization.
• made multiple formatting adjustments to ensure consistent code style throughout the project.
• implemented the pci module, focusing on memory allocation and control flow to handle device interactions.
• fixed typos in ktest documentation and comments to improve clarity and maintainability.
• worked on stubbing out ktest functionality, laying the groundwork for future testing features.
• addressed whitespace issues in several files to maintain code readability and adherence to style guidelines.

📓 devlog · 2026-08-13

• formatted various files for consistency, improved readability across the codebase.
• performed multiple cleanup tasks, removing dead code and refactoring functions for better maintainability.
• wired up the pci subsystem, ensuring proper connection and control flow with existing components.
• started initial implementation of ktest, laying out the basic structure and functions required for testing.
• tidied up the pci module by organizing functions and consolidating related code segments.
• addressed whitespace issues in several files to enhance overall code quality.
• stubbed out ktest functions to create placeholders for future testing scenarios and implementations.

📓 devlog · 2026-08-12

• cleaned up various modules, removed unused imports and redundant code for better readability and maintainability.
• fixed whitespace issues across multiple files to ensure consistent formatting and adhere to coding standards.
• fleshed out the pci module, implementing initial structures and outlining the control flow for device communication.
• tidied up the ktest module, improved the organization of test cases and ensured proper initialization of test variables.
• stubbed the ktest module to establish a framework for future unit tests, setting up basic test cases without implementation.
• started the pci module, laying the groundwork for further development and integration with existing components.

📓 devlog · 2026-08-11

• added initial implementation for pci, structured to facilitate device communication in the system.
• performed multiple cleanup operations across the codebase, focusing on removing redundant code and improving readability.
• fixed whitespace issues in several files, enhancing consistency in formatting.
• refined the pci module’s layout to ensure efficient data flow and reduce memory overhead.
• ensured all cleanup efforts adhered to the existing coding standards, promoting maintainability.
• adjusted comments and documentation to reflect recent changes, particularly for the pci module.

📓 plan · 2026-08-10
I’m starting the day later than usual, so I plan to tackle the whitespace fixes first to ensure our code adheres to the style guide. Once those are out of the way, I’ll focus on fleshing out the PCI subsystem, aiming for a more robust memory layout and control flow that supports our concurrency model. The evening will be dedicated to cleanup and further tidying of the PCI components, wrapping up with formatting to maintain consistency. If all goes well, I’ll end the day with a well-structured and polished segment of the codebase.

📓 devlog · 2026-08-09

• added ata module, structured data layout to optimize access patterns and reduce allocation overhead.
• implemented ktest, focusing on the test harness for kernel functionalities, ensuring control flow is correctly validated.
• wired up pci, improved integration with ata, facilitating better data transfer between components.
• tidied up ata, removed unnecessary complexity in the data handling logic to enhance maintainability.
• fixed typos in ktest to improve readability and avoid potential confusion in the test cases.
• worked on rough ktest, established initial test cases for future enhancements and iterations.

📓 devlog · 2026-08-07

• implemented ata, added core functionality and basic data processing logic.
• started ktest, set up initial test structure with basic stubs for functionality.
• fleshed out ktest, integrated test cases and improved coverage for ata interactions.
• cleaned up codebase, removed unused variables and simplified function calls across modules.
• performed multiple formatting updates, ensured consistent indentation and styling in source files.
• created stubs for ata, outlined functions for future implementation.
• addressed whitespace issues, standardized whitespace across all files for better readability.

📓 devlog · 2026-08-06

• tidied up the acpi module, removed unused variables and streamlined function calls for better readability.
• started work on the acpi module, established initial data structures for handling ACPI tables.
• performed whitespace fixes across multiple files to maintain consistent formatting, aiding in code maintainability.
• initiated ktest module, set up basic test framework for kernel testing.
• tidied up ktest, improved code organization by grouping related functions and reducing code duplication.
• began rough implementation of ata support, focused on defining data structures for device management.
• implemented core ata functionality, ensuring proper handling of ATA commands and data transfers.

📓 devlog · 2026-08-05

• added cpu module with basic structure and initial function outlines for core operations, set up initial memory allocation patterns.
• tidied up cpu code to improve readability, removed unused variables, and streamlined control flow in functions.
• began implementation of acpi, defining key data structures and laying out the function signatures required for system power management.
• wired up ktest to interface with cpu and acpi modules, ensuring proper data flow and control between the components.
• performed multiple cleanups throughout the codebase, focusing on removing redundant code and addressing formatting inconsistencies.
• fleshed out ktest to include test cases for cpu and acpi functionality, verifying expected behavior under various scenarios.

📓 devlog · 2026-08-04

• added initial structure for rtc, defined basic functions and headers for timekeeping.
• implemented core rtc functionality, allowing for setting and getting time with precision.
• cleaned up memory allocation in the cpu module, optimizing data access patterns.
• wired up cpu to handle rtc interrupts, ensuring correct handling of time-based events.
• fixed several whitespace and formatting issues across multiple files for consistency.
• addressed a typo in rtc definitions to prevent compilation errors.
• started work on syscall implementation, focusing on establishing foundational interfaces.

📓 devlog · 2026-08-03

• implemented syscall in the kernel, handling input and output operations for better interaction with user processes.
• wired up syscall to ensure proper communication between user space and kernel space, adjusting control flow for seamless execution.
• cleaned up codebase multiple times, focusing on removing redundant code and improving readability across various modules.
• added stub for rtc, laying the groundwork for real-time clock functionality, enabling time management features in future updates.
• addressed whitespace issues in several files, ensuring consistent formatting and adherence to style guidelines throughout the project.

📓 devlog · 2026-08-02

• started initial implementation of the scheduling module, focusing on basic structure and control flow.
• sketched out the keyboard input handling, defining data layout and key event management.
• performed a cleanup of the existing codebase, removing unused variables and improving readability.
• fixed a typo in the scheduling module that could lead to misinterpretation of scheduling logic.
• wired up the keyboard functionality to capture input events, ensuring proper allocation of resources for key states.
• cleaned up whitespace across multiple files, improving overall code consistency and formatting.
• stubs created for keyboard handling, setting the stage for future development of input features.

📓 devlog · 2026-08-01

• implemented physical memory management (pmm), structured memory allocation routines to handle page frames efficiently.
• added a programmable interrupt controller (pic), designed to manage hardware interrupts with a focus on prioritization and handling edge cases.
• started input subsystem, defined initial data structures and control flow for handling keyboard events.
• fixed typos and cleaned up whitespace across various files to improve code readability and maintainability.
• implemented keyboard handling, established key state tracking and event generation for input processing.
• performed multiple rounds of formatting and organization on the input code to align with project standards.
• created stubs for future input features, ensuring basic structure without full implementation for now.

📓 devlog · 2026-07-30

• added physical memory management (pmm) module, implemented basic allocation and deallocation routines for memory blocks.
• fleshed out pmm with additional functions for tracking free memory and fragmentation reduction strategies.
• wired up pmm with the scheduler, ensuring proper memory allocation during task creation and context switching.
• started work on the scheduler, focusing on establishing control flow for task prioritization and execution sequence.
• performed whitespace fixes across multiple files to improve code readability and maintain consistency.

📓 devlog · 2026-07-29

• removed unused variables in the scheduler module, improving readability and reducing confusion.
• organized the scheduling logic into smaller functions, enhancing maintainability and clarity in control flow.
• started work on the physical memory manager, focusing on the initial layout and allocation strategy.
• added basic structure for the physical memory manager, ensuring it aligns with existing memory management routines.
• performed multiple cleanups across the codebase, addressing formatting issues and whitespace for consistent style.
• iterated on the physical memory manager with rough implementations to establish a foundation for future development.

📓 devlog · 2026-07-28

• implemented basic structure for the ring buffer, focusing on data insertion and deletion mechanics.
• fixed issues in the ring buffer related to overflow conditions, ensuring proper wrap-around logic.
• started initial work on the scheduler module, defining its role in managing task execution order.
• cleaned up code in various modules, removing unused variables and optimizing function calls for clarity.
• made progress on physical memory management (pmm), refining allocation strategies and data structures.
• wired up pmm with the existing memory system, ensuring compatibility with current allocation patterns.
• cleaned up and sketched additional plans for pmm, setting groundwork for more advanced features.

📓 devlog · 2026-07-25

• added a slab allocator to manage memory allocation more efficiently, reducing fragmentation and improving performance for small objects.
• implemented a rough version of the slab with basic allocation and deallocation logic, focusing on a fixed-size object layout.
• created a sketch for the slab design, outlining the data structures needed for cache management and object tracking.
• performed multiple cleanup commits to improve code readability, removing unnecessary whitespace and standardizing formatting.
• fixed a typo in the slab implementation to ensure consistency in naming conventions across the module.
• added stubs for future slab functionality, allowing for easier expansion and integration of additional features later. 📓 devlog · 2026-07-25
• added a slab allocator to manage memory allocation more efficiently, reducing fragmentation and improving performance for small objects.
• implemented a rough version of the slab with basic allocation and deallocation logic, focusing on a fixed-size object layout.
• created a sketch for the slab design, outlining the data structures needed for cache management and object tracking.
• performed multiple cleanup commits to improve code readability, removing unnecessary whitespace and standardizing formatting.
• fixed a typo in the slab implementation to ensure consistency in naming conventions across the module.
• added stubs for future slab functionality, allowing for easier expansion and integration of additional features later.

📓 devlog · 2026-07-25

• added a slab allocator to manage memory allocation more efficiently, reducing fragmentation and improving performance for small objects.
• implemented a rough version of the slab with basic allocation and deallocation logic, focusing on a fixed-size object layout.
• created a sketch for the slab design, outlining the data structures needed for cache management and object tracking.
• performed multiple cleanup commits to improve code readability, removing unnecessary whitespace and standardizing formatting.
• fixed a typo in the slab implementation to ensure consistency in naming conventions across the module.
• added stubs for future slab functionality, allowing for easier expansion and integration of additional features later.

📓 devlog · 2026-07-24

• implemented paging, added core functionality for memory management, ensuring proper control flow for page allocation and deallocation.
• fleshed out paging, defined page structures and their associated metadata for efficient access patterns.
• wired up slab, integrated slab allocation with paging to optimize memory usage and reduce fragmentation.
• rough paging, established initial framework for paging algorithms, focusing on basic page replacement strategies.
• performed cleanup in various modules, removing redundant code and improving readability.
• formatted code across multiple files, ensuring consistency in style and adherence to project guidelines.
• worked on libk, progressing on utility functions to support paging and slab management.

📓 devlog · 2026-07-23

• performed general cleanup across multiple files, removed unused variables and streamlined functions for better readability.
• initiated work on libk, added initial sketches for core functions and data structures, focused on modular design.
• formatted existing code for consistency, ensured alignment with style guide across all modified files.
• stubbed out additional functions in libk, set up basic structure for future implementation, no functional changes yet.
• implemented rough drafts of key algorithms in libk, focused on establishing functional outlines and placeholders.
• added sketches for paging functionality, laid ground for memory management, still a work in progress.
• fixed multiple instances of whitespace inconsistencies, ensured code meets formatting standards.

📓 devlog · 2026-07-22

• stub libk, added initial placeholder functions to define the interface and structure for future implementation.
• sketch libk, outlined key functionalities and features expected in libk to guide further development.
• ok actually fix libk, resolved an existing issue in the libk implementation that impacted function performance.
• cleanup, removed unnecessary code and comments in multiple files to improve readability and maintainability.
• formatting, standardized code formatting across several modules to ensure consistency in style and layout.
• add pic, integrated initial assets and images required for the project, ensuring proper paths and references.
• rough libk, created a basic version of libk to provide a foundational structure for ongoing enhancements.

📓 devlog · 2026-07-21

• added rough implementation of timefmt, establishing a basic structure for time formatting functionality.
• cleaned up code formatting across several modules to improve readability and maintainability.
• created stubs for timefmt, setting up placeholder functions for future development and integration.
• fixed a typo in the timefmt module, ensuring correct naming and preventing potential lookup errors.
• began work on paging, focusing on the initial design for memory management and data access.
• started implementing libk, aiming to enhance core library functions related to kernel operations.
• tidied up libk, removing unused code and optimizing existing functions for better performance.

📓 devlog · 2026-07-20

• implemented rough version of timefmt, focusing on initial parsing logic for time strings.
• wired up timefmt to the main application flow, ensuring it integrates correctly with existing date handling.
• sketched out the overall structure of timefmt, laying the groundwork for future enhancements.
• fixed whitespace inconsistencies in several files for better readability and maintainability.
• addressed a typo in the timefmt module to prevent potential runtime errors.
• performed additional cleanup across the codebase, removing unused variables and functions.
• added a stub for timefmt to facilitate further development and testing.

📓 devlog · 2026-07-19

• implemented rough version of timefmt, focusing on initial parsing logic for time strings.
• wired up timefmt to the main application flow, ensuring it integrates correctly with existing date handling.
• sketched out the overall structure of timefmt, laying the groundwork for future enhancements.
• fixed whitespace inconsistencies in several files for better readability and maintainability.
• addressed a typo in the timefmt module to prevent potential runtime errors.
• performed additional cleanup across the codebase, removing unused variables and functions.
• added a stub for timefmt to facilitate further development and testing.

📓 devlog · 2026-07-18

• modified pic module to include initial implementation and basic structure, established interface for adding images.
• expanded functionality of pic module, incorporated methods for adding and manipulating image data.
• began initial work on timefmt module, implemented rough outline for time formatting functions.
• fixed identified issues in timefmt, corrected incorrect time string conversions and edge cases.
• performed multiple iterations and cleanups on timefmt, ensuring consistent formatting and removal of redundant code.
• addressed whitespace issues throughout the codebase, maintaining code readability and standards.
• completed additional stubs for timefmt, preparing for future enhancements and detailed functionality.

📓 devlog · 2026-07-17

• started working on the vga module, established initial structure and placeholder functions for further development.
• cleaned up existing code, focused on reducing redundant lines and improving readability across various modules.
• fleshed out vga functionality, added basic rendering capabilities and memory layout for pixel data.
• implemented a timer system, ensuring precise tracking of time intervals, adjusted allocation for timer objects.
• added stubs for pic and timefmt modules, set up basic function signatures for future implementation.
• made multiple whitespace fixes across all files to conform to coding standards and improve consistency.
• tidied up pic module, streamlined control flow and ensured compatibility with vga rendering logic.

📓  devlog · 2026-07-16 implemented serial communication module, established basic data transfer protocols and control flow.
added serial interface to the main system, allowing for external device communication.
fleshed out serial functionality, including error checking and buffer management.
wired up serial connections for data transmission, ensuring correct pin mappings and signal integrity.
sketched out io module structure, focusing on input/output handling and data processing paths.
added initial io functions, implementing basic read/write capabilities for peripheral devices.
began rough implementation of vga module, focusing on pixel data handling and display timing.

📓 devlog · 2026-07-15
implemented console, added basic input/output functionality for user interaction through standard input and output streams.
wired up console, ensured proper integration with the main application loop for event handling.
implemented blockcache, optimized data retrieval by caching frequently accessed blocks in memory.
wired up blockcache, linked it to the data storage layer to enhance read performance.
stubbed and tidied paging, established the foundational structure for memory paging without full implementation yet.
tidied serial, cleaned up the existing codebase for serial communication, improving readability and maintainability.
added serial, integrated serial port communication for external device interaction, allowing data transfer between the application and peripherals.

📓 devlog · 2026-07-14
added initial work on interrupt handling, defined basic structure for interrupt service routines.
performed code cleanup to improve readability, removed unnecessary comments and streamlined function definitions.
cleaned up formatting across several files to adhere to style guidelines, ensuring consistent indentation and spacing.
created stub implementations for interrupt handlers, laying groundwork for future development and testing.
sketched out a more detailed design for interrupt architecture, focusing on data flow and control mechanisms.
tidied up existing interrupt code, organized functions, and reduced duplication in the implementation.
continued refining interrupt handling logic, addressing edge cases and ensuring proper allocation of resources.

📓 devlog · 2026-07-13
added stub interrupts to initialize interrupt handling in the system, setting up for further implementation.
created a work-in-progress blockcache module, laying the groundwork for efficient data storage and retrieval.
implemented the timer functionality, ensuring accurate time tracking within the system for scheduling tasks.
cleaned up various modules including blockcache and interrupts, improving readability and maintainability of the code.
fleshed out timer implementation details, refining the control flow for better performance in timing operations.
performed multiple formatting fixes across files for consistent coding style, aiding in future collaboration.
organized and tidied blockcache code, improving memory layout and preparing it for future enhancements.

📓 devlog · 2026-07-12
cleaned up interrupt handling code, focused on reducing redundancy and improving readability without changing functionality.
implemented stubs for interrupt functions to facilitate future development, allowing for easier testing and integration.
performed multiple whitespace fixes throughout the codebase to maintain consistency in style, improving overall readability.
formatted code to align with the project’s style guide, ensuring uniformity across various modules and files.
addressed various cleanup tasks, removing unused variables and optimizing import statements for better organization.
worked on interrupt-related functionality, marked as work in progress, which requires further testing and validation.
applied additional tidying to interrupt handling to ensure clear control flow and efficient resource management.

📓 devlog · 2026-07-11
added basic interrupt handling, defined interrupt vectors and handlers for specific events, ensuring correct execution flow.
cleaned up existing code, removed unused variables and streamlined function definitions for better readability and maintainability.
implemented rough interrupt logic, focused on initial data capture and processing for incoming signals from hardware.
tidied up the interrupt code, organized structure for clarity, and ensured consistent naming conventions across handlers.
performed multiple whitespace fixes and formatting adjustments, ensuring adherence to style guidelines throughout the project.
worked in progress on interrupt functionality, laying groundwork for future enhancements and optimizations in response handling.

📓 devlog · 2026-07-10
implemented wiring for idt, ensuring proper interrupt handling flow.
created initial sketches for gdt, focusing on data structure layout and alignment.
performed multiple whitespace fixes across files for improved readability.
refined gdt implementation with rough and tidy stages, optimizing memory layout.
wired up gdt, enabling segment-based memory management for the system.
cleaned up interrupt wiring, enhancing control flow during interrupt processing.
standardized formatting across the codebase to maintain consistency and clarity.

📓 devlog · 2026-07-09
fleshed out README content to provide clearer project guidelines and usage instructions, improved overall clarity.
made multiple formatting adjustments across the README files to ensure consistency and readability.
started and wired up the initial draft of the interrupt descriptor table (idt), focusing on basic structure and future implementation.
added stubs for idt functions, preparing for further development while ensuring initial code integrity.
corrected a typo in the idt implementation, ensuring accurate naming conventions in the codebase.
performed cleanup tasks on both README and idt files, removing redundant lines and improving organization.