Inside Computing

@robotaxi Can I have One ?

Gold rush

@milichab @elonmusk I will try

Big updates next week :)

What is QEMU? Developed originally by Fabrice Bellard in 2003, QEMU is a generic, open-source machine emulator and virtualizer. While common virtualization software like VirtualBox or VMware only lets you run virtual machines that match your computer’s hardware (e.g., running x86 Windows on an x86 Linux PC), QEMU can cross the ISA boundary. It allows your x86_64 Intel/AMD processor (or ARM-based Apple Silicon Mac) to mimic a 64-bit RISC-V CPU so perfectly that the Linux kernel cannot tell the difference.

Looking to dive into RISC-V without spending a dime on hardware? QEMU is your ultimate playground. You can emulate a full 64-bit RISC-V Linux system right on your current machine in just minutes. Why this combo is a game-changer for devs: 🔹 Zero-cost development: Test architectures before buying silicon. 🔹 Perfect for kernel hacking: Debug and trace everything with ease. 🔹 CI/CD friendly: Spin up RISC-V environments in your build pipelines seamlessly. Stop waiting for hardware delivery. The open-source instruction set architecture (ISA) future is already running on your machine. #RISCV #QEMU #OpenSource #EmbeddedSystems #Linux #TechCommunity

Linux opened the software world. RISC-V is opening the interface between software and the processor. youtu.be/PL0DCzKFGJ8 So why are Linux and RISC-V considered a perfect match? How tools such as GCC, LLVM, QEMU, OpenSBI, and U-Boot help build a complete RISC-V Linux ecosystem. #Linux #RISCV #OpenSource #ComputerArchitecture

@elonmusk True

Robot fights are fun 😂

@elonmusk Sure, I will

Try Grok Build x.ai/cli

@elonmusk That is nice

Grok Build improves almost every day

The biggest misconception in computer architecture: youtu.be/HN1yRMSFEv0?si… x86 CPUs don’t actually execute x86 instructions directly. They decode them into internal micro-operations first. Today’s Intel and AMD processors look far more RISC-like internally than most people realize. The CISC vs RISC debate changed forever.

Contact us here: fpgamarketing.com/contact/

if you want us to sell your embedded products and hardware, please contact us

The momentum is unstoppable. With the RISE Project (RISC-V Software Ecosystem) pumping commercial backing into the software layer, the gap is closing fast. We’re moving from "hobbyist toys" to edge, IoT, and eventually server-grade deployments. We are watching the birth of a third major computing ecosystem in real-time.

The Reality Check: What’s still holding us back? 1. Extension "Fragmentation": Because RISC-V is modular, different vendors pick different extensions. Writing software that runs optimally across all chips is a moving target. 2. The GPU Bottleneck: The CPUs are open, but many budget boards still bundle closed-source, proprietary GPU IPs. Fully open graphics is still a struggle. 3. Software JIT Optimization: Runtimes like V8 (JS), JVM, Rust, and Go are compiled, but still lack the deep micro-architectural optimizations of ARM/x86.

Linux + RISC-V is a match made in heaven: A completely open-source OS running on an open-standard ISA. youtu.be/IqLOPZWOOvw?si… But for years, "Linux on RISC-V" felt like an academic toy or a painful hobby. Well, things have changed. We are officially in the era of real, usable systems. A quick thread on how we got here & what’s still holding us back. 👇

How it’s going: Real silicon is here & cheap. Today, the barrier to entry has plummeted: Affordable SBCs: StarFive VisionFive 2, Milk-V, and Lichee Pi have brought 64-bit Linux boards down to the $50–$100 range. Vector Extensions (RVV 1.0): Mass-produced chips now feature vector extensions, boosting crypto, media, and local AI. Distros: Debian, Fedora, Ubuntu, and Arch now have active, native ports.

How it started: "Just get it to boot." In 2018, running Linux on RISC-V meant: Relying heavily on QEMU software emulation. Buying a $999 SiFive HiFive Unleashed dev board (if you had the cash). Painfully slow upstreaming to the main Linux kernel. It was a triumph of patience, not performance.

Step 3: Getting Processor Time ⏱️ The OS scheduler sees the new ⁠ls⁠ process waiting in the queue. It allocates a tiny sliver of CPU time (a timeslice) and assigns a CPU core to begin executing the machine instructions of the ⁠ls⁠ program.

Step 2: The Cloning Process (⁠fork⁠ & ⁠execve⁠) 🧬 The shell can't run ⁠ls⁠ inside itself, or a crash would kill your terminal. Instead, it calls ⁠fork()⁠ to clone itself into a child process, which then calls ⁠execve()⁠ to load the ⁠ls⁠ binary into memory.

We type ⁠ls⁠ dozens of times a day. It feels instant. youtu.be/9PkIYK9tdAI?si… But under the hood, your OS is conducting a massive, highly coordinated symphony. In just a few milliseconds, a simple command travels through the entire Linux stack. Here is the epic journey of ⁠ls⁠ 🧵👇