From 7caa3cfa2a29889d73caf3b50d7a1579c3d910d7 Mon Sep 17 00:00:00 2001 From: Nicola Belluti Date: Tue, 18 Nov 2025 15:27:30 +0100 Subject: [PATCH] Added the homepage contents --- content/_index.md | 201 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 200 insertions(+), 1 deletion(-) diff --git a/content/_index.md b/content/_index.md index 031d2ff..e698fae 100644 --- a/content/_index.md +++ b/content/_index.md @@ -4,7 +4,7 @@ layout = "wide" {{< hextra/hero-container cols="1">}} -{{< hextra/hero-badge >}} +{{< hextra/hero-badge link="#licensing" >}}
An open-source learning project {{< icon name="book-open" attributes="height=14" >}} @@ -39,4 +39,203 @@ layout = "wide" {{< /hextra/hero-container >}}
+
+ {{< hextra/hero-section heading="h2" >}}What is this thing?{{< /hextra/hero-section >}} +
+ + If you're curious about how computers really work under the hood, the *Little + Computer* family is a great place to start. + + The *Little Computer* is a family of *Instruction Set Architectures* + ([ISAs](https://en.wikipedia.org/wiki/Instruction_set_architecture)) based on + the Von Neumann model, created by [Yale N. + Patt](https://users.ece.utexas.edu/~patt/) and [Sanjay J. + Patel](https://sjp.ece.illinois.edu/) to help students learn the fundamentals + of computer architecture in a clear and approachable way. + + These architectures are intentionally simple. They use a *very* + [RISC](https://en.wikipedia.org/wiki/RISC) instruction set, a linear memory + model, and a small number of registers and addressing modes. Their design + focuses on being **understandable rather than realistic**, making them ideal + for learning how a CPU works from the inside out. + + Across the different iterations -- from the early LC-2 to the LC-3 and LC-3b + -- the overall structure stays consistent. Each version slightly expands on + the previous one, adding refinements such as new instructions or different bus + widths while preserving the same conceptual model. + + The most famous ISA in the family is without a doubt the **LC-3**, widely used + in universities around the world. It has inspired a + [subreddit](https://reddit.com/r/lc3), a [Wikipedia + page](https://en.wikipedia.org/wiki/Little_Computer_3), online tools such as + [lc3web](https://wchargin.com/lc3web/), and countless course materials. Yet + despite its popularity, complete and freely accessible documentation for these + architectures is surprisingly fragmented or hard to find. + + This project aims to bring everything together in one place - a clean, open, + and modern documentation that makes the Little Computer family easier to + study, explore, and build upon. + +
+ {{< hextra/hero-section heading="h2" >}}Why am I doing this?{{< /hextra/hero-section >}} +
+ + If you want to learn computer architecture today, you usually face two + options: either you study a full CISC architecture like x86, which is + enormously powerful but incredibly complex, or you work with a simplified + subset of an existing architecture, such as Tiny MC68000, which often removes + or abstracts away the very mechanisms you're trying to understand. + + By instead learning a compact, coherent, and intentionally simple + architecture, students can genuinely grasp how computation works -- + instruction execution, addressing, control flow, data movement -- without + being overwhelmed by historical baggage or modern optimizations. This is + exactly what makes the Little Computer family so valuable: it provides a + complete, understandable model of a real CPU without unnecessary complexity. + + I'm building this project to make these ISAs easier to discover and study. + Much of the existing material is scattered, incomplete, or tied to specific + textbooks, so offering modern, open, and well-organized documentation felt + necessary. + + There's also a personal side to it. I'm using this project as a way to learn + too, both to deepen my understanding of how computers operate at a fundamental + level and, as a newcomer to retro computing, to explore the kind of + transparent, elegant designs that defined early systems. The Little Computer + family captures that spirit perfectly. + +
+ {{< hextra/hero-section heading="h2" >}}Roadmap{{< /hextra/hero-section >}} +
+ + This project is highly a **work in progress**: things will grow, change, and + refine as the documentation evolves. + + Before diving into details, here's a high-level overview of where the project + is heading. + + ### Legend + + * 🛠️ **Work in Progress** - currently being worked on + * 🎯 **Planned** - part of the main roadmap, not started yet + * 🚀 **Ambitious** - long-term ideas that would be amazing to explore + + {{% steps %}} + + ### 🛠️ Write clear, complete documentation + + I'd like to explain the basics of computer architecture from the ground up - + starting with boolean logic and binary representation, then slowly building + the components of a CPU. It won't be a full university-level architecture + course, but it will cover the foundations clearly and accessibly. + + I also want the documentation to be filled with citations, so anyone can + verify sources and understand where each detail comes from. The existing LC + material is scattered or unclear, so consolidating everything into one open, + trustworthy reference is essential. + + ### 🎯 Build a basic development suite + + Once the docs are solid, the next step is creating simple command-line tools: + + * An **emulator**, + * An **assembler**, + * A **linker**, + * And **small utilities** for experimenting with programs. + + The idea is to offer lightweight, modern, educational tools that don't depend + on outdated software. + + ### 🎯 Create a graphical learning environment + + After the CLI tools are stable, the goal is to develop a GUI environment with: + + * An integrated **editor**, + * A **register/memory inspector**, + * And a **step-by-step execution view**. + + Everything in one cohesive, clean, **expandable** application. + + ### 🚀 Build a physical implementation (FPGA) + + Inspired by projects like [Ben Eater's "Building a 6502 computer from scratch" + series](https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1mu7dp7eH), + a long-term goal is to bring the LC architecture into real hardware using an + [FPGA](https://en.wikipedia.org/wiki/Field-programmable_gate_array). + + The idea is to recreate the experience of wiring the datapath by hand: LEDs + for registers, switches for inputs, clock controls, memory chips, and a + physical layout where you can literally trace how instructions move through + the system. It would be an incredible way for students (and for me!) to *see* + the CPU come alive, one wire at a time. + + ### 🚀 Port classic software + + Porting small classic programs: DOOM, Tetris, MS-BASIC, tiny shells, demos, or + classic educational tools + + This would be a fun and effective way to stress-test both the architecture and + the entire toolchain. + + The goal isn't just to "make things run", but to explore what it means to + adapt real software to a minimal ISA: rewriting rendering loops, designing + tiny I/O layers, optimizing for limited memory, and understanding how classic + programs were structured on simple computers of the past. + + These ports would also serve as great examples for students, showing how + real-world logic and old-school game mechanics map onto assembly instructions, + registers, control flow, and memory access patterns. + + ### 🚀 Porting a compiler toolchain + + A long-term goal is to experiment with bringing a modern compilation toolchain + to the platform, for example by developing a minimal LLVM backend. This would + make it possible to compile higher-level languages and would open the door to + teaching concepts like code generation, optimization, and compiler design in a + very approachable way. + + ### 🚀 Build a small UNIX-like operating system + + With a stable architecture and toolchain, building a tiny operating system + becomes a realistic and exciting challenge. The idea is not to recreate a full + modern OS, but to implement the core concepts that made early UNIX systems + elegant and teachable: a simple process model, a basic exception/interrupt + system, low-level device drivers, a minimal filesystem, and a tiny shell to + run programs. + + Such an OS would act as the "glue" that ties together everything learned so + far -- instruction execution, memory management, I/O routines, and + system-level programming -- while giving students a clear view of how + operating systems are structured at their simplest and most transparent level. + + {{% /steps %}} + +
+ {{< hextra/hero-section heading="h2" >}}Licensing{{< /hextra/hero-section >}} +
+ + This project is entirely open source! + + The documentation is distributed under the [Creative Commons + Attribution-NonCommercial-ShareAlike + 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) license, and the + source code is distributed under the [GNU Affero General Public License + v3.0](https://choosealicense.com/licenses/agpl-3.0/). Feel free to take this + work, study it, modify it, improve it, and redistribute it  ; ) + + If you feel generous, please consider opening a PR on the project's GitHub + page so that everyone can benefit from your contributions. + +
+
+ + {{< hextra/feature-grid cols=2 >}} + {{< hextra/feature-card + title="Little Emulator" + icon="github" + subtitle="Check out the project's code!" + link="https://github.com/little-emulator" + >}} + {{< /hextra/feature-grid >}} +