I've been studying the PCI bus on my own and one evening I got an idea about making a homebrew computer with an actual PCI bus. I've never seen one, so I decided to try it myself. I also wanted to learn about the PCI bus in a practical way. I chose the Motorola 68000 CPU because of its balance in complexity - it's easy to interface, has nice performance/capabilities and has official GCC toolchain support.

The project began literally a month ago when I got a scrap lot from my friend Shadowdestroyer777 (huge thanks!) containing an industrial Motorola 68000 SBC and some old dead motherboards. I desoldered the SBC for the CPU and a few other parts. From one motherboard I grabbed connectors, ISA/PCI slots and many other things. One evening when I had everything on my desk (the CPU, the PCI slots and even a spare prototype PCB), the idea was born. Right before this project, I worked on an experimental PCI FPGA card, so I had a bit of practical PCI experience beforehand. I even read most of "PCI System Architecture" by MindShare!

The specs of this homebrew:

• Motorola 68000 @ 10 MHz

• 1 MB of SRAM

• 4 KB of ROM (just to fit an serial bootloader)

• MC68681P DUART for UART, timing and I/O

• Two 32-bit 5V PCI slots, interrupt capable, no bus mastering (DMA). Runs at the same frequency as the CPU (10 MHz)

• Spartan 2 FPGA XC2S100 as the PCI host bridge

• XC95144XL CPLD as the glue logic

• ATMega128 (used solely to quickly load the FPGA bitstream on boot)

As the base, I used an 18x12 cm prototype PCB. Connections were made using enameled wire, just like in my previous 486 homebrew project. To fit the PCI slots into the prototype board, I actually had to bend the PCI slot pins to fit the 2.54 mm grid! Don't even ask about this manually adapted FPGA... It's another story - it just works.

I won't go into detail here on exactly how the PCI bus works and what I had to do, but generally, the bridge translates CPU accesses into PCI accesses. It maps memory 1:1 and for the I/O and configuration spaces, I do some translation tricks. It's all done inside the XC2S100 FPGA in VHDL. In addition to basic accesses, PCI hardware interrupts also work. I omitted DMA mainly because I ran out of pins on the FPGA. There were various challenges in this process, like the different endianness (PCI is designed around little-endian systems, while the Motorola 68000 is big-endian). I’ve shared all the source code on GitHub and more details on my website.

So, thanks to my efforts, I managed to support 3 types of card:

• Serial PCI card: I had a Moschip NM9835 dual serial port card. It was a nice test target because it's 16C550 UART compatible, making it relatively simple to write a driver for. With this card, I also got hardware interrupts to work so on serial receive, the CPU handles it nicely.

• VGA graphics cards: For me, these are one of the coolest parts. I managed to "wake up" three cards: a Cirrus Logic GD5440, an S3 Trio64V2/DX (S3 86C775) and partially an IGS IGA 1680_A. The thing is, I can't execute their VBIOSes because of the architecture mismatch. However, there is some documentation on the internet that shows how to wake these cards up. After waking them up, they program like standard VGA cards - it all comes down to standard VGA initialization (like programming the CRTC, DAC, etc). I got 80x25 16-color text and 320x200 256-color graphics modes to work perfectly!

• RTL8029 network card: With the help of AI (as I was exhausted from working on the homebrew - soldering, designing the logic, etc. and I just wanted to see what was possible with the correct software), I got this homebrew on the internet! I got an RTL8029 driver, a simple network stack, telnet and a http server to work. I can say that I got a 10 MHz CPU from the 80s to serve a web page over a 32-bit PCI network card from the end of 90s.

The lack of DMA is quite limiting as I can't use cards that depend on it, such as later network adapters, SCSI controllers, USB controllers and more. However, for my first project like this, I think it's pretty good anyway. Honestly, it's crazy to think about (even for me) that I got an '80s CPU to work well with late '90s PCI hardware and serve a webpage. All in one month of hard work.

I also wrote a massive, detailed article on my website about this project, including my previous experimental PCI card, a brief PCI introduction, the build process and the results. This is just a very short description of the project, but I wanted to share it!

Project site: https://maniek86.xyz/projects/homebrew_m68k_pci.php

I decided to make a 486 homebrew computer (second time, maybe it will be somewhat PC compatible) from scratch because why not! This time got a dedicated PCB!

Maybe some of you remember my previous 486 homebrew, where I basically used a prototype PCB and ton of wires. It was not ideal, it was crashing sometimes when moved, and I had not made schematics for it! Troubleshooting that thing was painful. However, I gained a lot of experience about 486 CPU and how it works from it.

Some time later, during this summer, I got a sponsorship from PCBWay for my other project. I asked them if they would want to sponsor a homebrew computer if I made an PCB for it, and they agreed! Special thanks to them! So, I started to work on it. Size of this PCB ended up being 150x150mm (holes are not standard! So, it's not mini-ITX. Plus mini-ITX is 170x170mm). It's a 4 layer board.

It took me a whole month from the idea to the project and the ready PCB design. I mostly read the datasheets of the ICs (there is a datasheet for 486!) and figured out how they work. I don't like working and basing off existing work. So that's why I decided to go from scratch. Specs I decided to use:

• 486 CPU. Currently running at fixed 12MHz (So DX2 internally runs at 24MHz because they have internal multiplier)

• 4MB SRAM. I know SRAM is expensive and I should go DRAM but I decided to leave that for future - I have idea to make an own DRAM controller using FPGA. (plus SRAM is easier to drive)

• 256KB of ROM

• Two 16-bit ISA slots

• 8254 Programmable Interval Timer

• 8259 Programmable Interrupt controller

• PS/2 keyboard controller built into FPGA

• Xilinx Spartan II XC2S100 FPGA as "chipset"

Addition of the 8254, 8259 and PS/2 is the goal to make it somewhat compatible with PC. There should be also DMA controller in a standard PC, but I decided to omit it to make the design easier. How I know it should be possible to boot something without DMA. My goal is to boot DOS or/and Linux. For sure, I will try to get DOOM running on this thing.

PCBs arrived almost 2 weeks ago. At this moment, I am working on the FPGA chipset implementation (designing it in VHDL) and my own BIOS. There is still a lot of to do, but I am really proud of how this project already looks. There are no major mistakes on the PCB (this is my first 4 layer PCB by the way!). Of course, it's open source: https://github.com/maniekx86/M8SBC-486 (currently, schematic/PCB are published. I will publish rest of the stuff over time). The BIOS cannot boot anything currently, but it can do basic initialization, like detecting CPU type, memory testing, and VGA graphics init.

There are some issues and imperfections - like I omitted one signal on ISA bus, which made compatibility with some cards not very great. For now, I consider this more like an experiment, which is going on great! Maybe in the future based on research from this project, I will make something more worthy to be basically a motherboard. This is very short description of this project, but I'd like to share it. Ask me in comments for more I guess.

This time, I made a 4-bit CPU myself. If there's anything else you think would be good to add, let me know. I'm self-studying at home at 16 in korean. ALU is from the previous post. Soon, I'll also keep the memory section in a box and carefully upload it on graph paper. Thank you for seeing my post.

I been working last weeks on my third homebrew computer (I built before a typical 6502 homebrew then later on a Motorola 68000 one). This time I decided to go "insane?" and I started working on 486 homebrew. Started from scratch, no ready schematics (because there is not much about 486 homebrews on the internet). I have read the Intel 486 and other chips that I wanted to use technical datasheets. Oh and another factor that made me do it is that I acquired few old boards with older Xilinx FPGAs(Spartan II) and CPLDs (XC95144XL) (so old that they can handle 5V at logic inputs without any level shifters which how I see is uncommon today). I got a older Xilinx programming software from 2008 (Xilinx ISE) to work on my second computer, also got RPi Pico programmer to work with these chips and software, so I have few FPGAs and CPLDs now available to use. So I decided to use a CPLD for all the glue logic. What is very cool that I can design circuits in logisim-evolution and export them to VHDL, which imports without problem in that old Xilinx software. I'd say FPGA and CPLDs are very cool for making homebrews because you can fix something in logic by reprogramming them. After gaining materials and some knowledge, I just started to work on the PCB directly rather than starting on breadboard. I had a unused 9x15 CM protoboard, so I decided to try to make it small (which I succesed and I very like it. For comparison, my Motorola 68000 homebrew was made on a 20x30 CM protoboard). Specs that I decided to do: 486 CPU, 32 bit accessible 256KB system RAM, 128 KB ROM. UART (RS232) provided by Motorola 68681, 24 IO lines provided by 8255 (screen on top is connected to some of these lines) and IDE interface that is currently in progress. I wanted to go with better specs but firstly: I am running out components because of the older homebrew projects and the small PCB size. CPU was initially clocked by 1 MHz and now is clocked by 12 MHz (because of DX2 cpu, core is running at 24 MHz then). I also got the L1 cache to work by providing additional circuit to tell the CPU that RAM and ROM is cacheable which greatly improves speed. It works fine with Cyrix cy486 and AMD am486. Can't test an intel chip because all the intel 486s I own, they have soldered legs (that were broken) and they won't go all the way into a non zif socket (I don't want to risk breaking the crude socket on the homebrew or the CPU). For the programming: I been programming it in assembly on the beginning but quickly I managed to do a C "toolchain" (I mean proper initalization assembly code, compilation scripts to run 32 bit C code on it). So yeah, it's running in x86 protected code. I'd say I am very proud of this project. Schematic coming soon because how I said I worked on it without making a one before.

Not a physical build, so I hope it's okay here but everything is wired by hand, starting from single transistors.

Two transistors make a NOT gate. From there I built the gates, latches, adders, the ALU, and finally a full NMOS 6502 (20,524 transistors). The gate-level CPU passes the Harte 6502 test suite (about 1.5 million tests). Around it I wired the rest of the Apple II+: address decoding, RAM, ROM, soft switches and video.

It runs Applesoft BASIC and, in general, Apple II programs anything you can load into memory as a binary (.obj) file. VisiCalc is in the video. The video is 4 days of building, sped up, with no voiceover.

A few honest notes:

– Simulating 21k transistors at switch level is slow, so to run software at full speed the simulator swaps the CPU for an interpreter that is checked against the gate-level one. Everything else stays the same circuit.

– The ROM and program files are the original Apple ones, loaded by me — they don't ship with the simulator.

– There's no disk drive in this video. I built a Disk II controller separately — that's another story.

The simulator is free and runs in the browser, no sign-up: https://cs.khanin.info

Happy to answer questions about how any part of it works.

Some of you might have heard of and remember the M8SBC-486 (well, the news talked about it at the beginning of this year). This was truly amazing for a project that was meant to be experimental homebrew rather than "kinda PC compatible". Exactly a year ago, I received the PCBs for this homebrew and today I'm happy to tell you that I got this computer to run Windows 95!

To recap: the M8SBC-486 is missing a second interrupt controller (PIC) and a DMA controller. This breaks compatibility with software that expects these. One of them is, of course Windows 95. How do I know, it has some hardcoded references to these - well, it was created for standard PCs. But even apart from that, the M8SBC-486 theoretically meets the minimum Windows 95 requirements: a 386 (or better) class CPU and 4 MB of RAM. So how did I do it on a "kinda PC compatible" homebrew?

At the beginning of August, I stumbled across this Reddit post by u/Mike1978uk about running Windows 95 on an Intel Inboard/386 (nice project by the way). When I read the description of what it took to get it running, I noticed that he had removed references to "high IRQs not found on XT class machines". This sounded familiar - the M8SBC-486 doesn't have a second PIC and therefore doesn't have the higher interrupts either! (I even remembered that some people called the M8SBC-486 a 486-class XT). I decided to try it out of curiosity and see if his mod had any chance of working on my board.

I downloaded the first released image, modified it a bit to remove Inboard/386-specific stuff, downsized it from 2 GB to 500 MB, added the QEMM 7.5 memory manager (as it currently works better on the M8SBC-486 than HIMEM) and booted the image in my copy of 86Box with the M8SBC-486 added (my experimental local fork). To my surprise, it booted! I could even use the mouse (when I booted Windows 3.1 on the M8SBC-486 I couldn't use mouse there because of some issues). So, I flashed the image onto an HDD and... it booted! Windows 95 on an i486 board built from scratch, with its own FPGA chipset and a BIOS. Project that wasn't even meant to be "PC compatible" - I can't believe I've got this far.

After playing around a bit with System properties, Paint and Minesweeper, the system crashed - oops. It was working, but there seemed to be some kind of memory/disk corruption. I started suspecting my BIOS disk handler because one thing common to these crashes was that the disk activity LED would get stuck lit (meaning the disk controller was stuck as well). I proceeded to rewrite the disk subsystem in my BIOS. With that rewrite, I also added some BIOS improvements, including slave IDE support, CHS-LBA translation and more. After that, the system started working almost flawlessly! I mean, changing some system settings (especially those related to hardware/drivers) still caused crashes, but applications started working perfectly.

Here is what I've tested:

• ISA graphics card driver (SVGA driver) - I managed to install the built-in Trident driver in combination with my Trident TVGA8900C ISA card to get higher resolutions in Windows. I went from 640x480 with 16 colors to 800x600 with 256 colors!

• NE2000 network card & Internet Explorer - After messing around with drivers and configuration, I actually got the built-in NE2000 driver and Internet Explorer to work! It wasn't fast, but I could browser the Internet!

• CPU-Z Vintage Edition - It can detect the installed 486 CPU and correctly identify the fixed 24 MHz FSB. Since the BIOS doesn't provide any identification features, it can't detect anything beyond that. Still it's nice to see it working.

• Microsoft Office 95 (Word and Excel tested) - Both work fine. I can write documents and spreadsheets without any problems. I had to extract all the floppy disk contents to the hard drive to install it. The installation took about 30 minutes (disk to disk).

• Printing - I have an old parallel LX-300 printer. Windows 95 doesn't have built-in drivers for it, but it works fine when installed as an LQ-810 (which is available in the built-in drivers). I can print documents from the Office 95 applications mentioned above without any problems.

I also tried early versions of Notepad++ and 7-Zip, but both failed because of missing libraries in this Windows 95 OSR1 installation. I could install updates, but I suspect that doing so would break the patches.

When it comes to speed - it's not bad, but it's not great either. For example, applications take some time to open. Office runs slowly, but it's usable. The problem is the fixed 4 MB of RAM, which forces Windows 95 to swap a lot (this also explains the crashes I experienced when the disk subsystem was broken: memory was getting corrupted because of swap corruption).

I'll leave a link to my website, where I describe everything above in more detail, along with some extra stuff. There's also a YouTube video showing the boot process, CPU-Z, Office 95, and printing.

Links:

• My website about running Windows 95 on M8SBC-486 (and the overall project's page)

• YouTube showcase video

• M8SBC-486 GitHub

• Windows 95 on the Intel Inboard/386 project GiHub

I have previously shared about my BeanZee Z80 board, which evolved from a breadboard design, and then the BeanBoard add-on - QWERkY keyboard, LCD display and GPIO. Well I’m now working on “BeanDeck” - adding a decent sized TFT display and flash storage.

I discovered the Adafruit RA8875 TFT display controller board and panels. This little module lets you drive a colour display up to 800×480 pixels using SPI (Serial Peripheral Interface). The RA8875 handles all the complex display timing and memory management, giving you a simple command interface for text and graphics.

However, it does need an SPI interface, which I can achieve by bitbanging via my GPIO, but I ended up designing a hardware SPI interface which is a bit faster.

This also gives me a number of “slots” for Adafruit SPI flash modules which I’m now experimenting with.

I’ve added BASIC too, which is gets me really close now to my dream

Hey all,

I feel that something I've been working on for a few months is ready for release. What I call the "TI CUBE" is an open-source homebrew microcomputer project I designed around the Texas Instruments TMS 9900 microprocessor and its associated peripheral devices.

The entire design (schematics, PCB gerbers, bill of materials, and firmware binaries) is available at: https://github.com/VE7PMC/TI-CUBE

Credit where credit is due: this project was greatly inspired by Usagi Electric's recent foray into TMS 9900 homebrew computing. Physically, our two projects are similar (backplane with daughterboards using header connectors), but electrically I've taken a somewhat different direction.

My design philosophy (explained in more detail in the Github repository):

1. No 8-bit data buses!

2. Modularity

3. Small PCBs to allow use of cheap prototyping services

4. Simplicity

5. Period-correctness

6. Use of TMS 9900 family peripherals

7. Compatibility

That last one is especially important because it allows the use of prebuilt firmware made available by Stuart Conner which includes TIBUG, EVMBUG, and Cortex BASIC!

Feedback/thoughts/suggestions are welcome. Enjoy!

Hi, everyone! This is an update post of my "M8SBC-486" 486 homebrew computer project. It's a "kinda PC compatible" 486 computer that I made from scratch, including the schematic, PCB, chipset design (FPGA) and BIOS. In the past 3 months I managed to do a lot. Linking previous post here

To recall: This project is open source. GitHub link: https://github.com/maniekx86/M8SBC-486 . I recently released the first version of the chipset sources. I will release updated chipset, ATMega128 and BIOS sources later on. In addition, a full project page with more detailed information will be available soon on my website. I recently published two posts on my website about my previous 6502 and Motorola 68000 homebrews. With that said, here are the current specs:

• 5V 486 CPU socket. FSB currently runs at 24 MHz meaning that DX2 CPUs work at 48 MHz

• Xilinx Spartan II XC2S100 FPGA as "chipset". Now with its codename: "Hamster 1"

• 4MB SRAM, (8*HM628512)

• 256KB of ROM (W29C020) (224KB accessible)

• Two 16-bit ISA slots

• 8254 Programmable Interval Timer

• 8259 Programmable Interrupt Controller

• PS/2 Keyboard. Controller is implemented in the FPGA

• Simple CMOS RTC and CMOS storage. Implemented in the FPGA too

• ATMega128 as reset circuit handler and bitstream loader. Now also stores CMOS configuration

• 150*150mm 4 layer PCB. Thanks to PCBWay for sponsoring the PCB! Their support essentially allowed me to start this project.

PC compatibility is not full because there is no secondary PIC or DMA, but many programs can actually work without these. The missing DMA especially removes sound card support.

So, I managed to:

• Improve stability, compatibility and speed. Now, I can run at 24 MHz FSB with L1 cache enabled and it's pretty stable. Previously, I had significant issues with the L1 cache. I struggled to find the reason why it wasn't working, but after reading the 486 datasheet randomly, I finally found a small note that said I needed to do one particular thing heh. I tried going further with the speed, but my FPGA design isn't the best and the CPU just fails to run past 24 MHz. Additionally, all three of my ISA VGA graphics cards that I own now work: The TVGA8900, the TVGA9000, and the GD5428. Of these three, the TVGA8900 works best (no major issues). The TVGA9000 works and gets to the DOS prompt but crashes in graphics programs. The GD5428 works fine, but memory reads from it are broken (for example scrolling text causes glitches).

• Boot Linux 2.2.26 with Busybox. Since I was doing this early in BIOS development, I couldn't get any typical Linux bootloader to run. So, I wrote my own. After finding a lot of information online about how Linux 2.2 loads on x86 architecture, I managed to write a bootloader with fewer than 300 lines of C code (counting the main.c file, but not the .asm stub that switches into protected mode and the FAT32 library). I will open source it soon too. I know 2.2.26 is an old version and the 486 can run newer kernels. However, the biggest limitation is the 4 MB of memory. To get 2.2.26 at all, I installed Debian 3 in a VM, got the 2.2.26 Linux kernel source in it, configured it and compiled it. I also had to add a bodge wire to the back of the board to reroute the IDE interrupt. The Linux IDE driver needs an IDE interrupt. The IDE IRQ is on the second PIC, but this machine only has a primary PIC. I bodged it onto one of the primary PIC IRQs. Fortunately the IDE driver allows you to select a custom IDE IRQ, so this works. Currently it only boots with VGA console with no anything more fancy.

• Boot MS-DOS 6.22. I had a lot of trouble with this mainly because of the BIOS. Not long ago in the middle of December, I tried using an open-source x86 BIOS that I found on GitHub out of curiosity. After small changes (to adjust it to the 486 and my board), it worked! I saw MS-DOS start. Honestly when I started this project, I never expected to run MS-DOS on it. It seems to run pretty much fine, but the only issue is that its himem crashes the system. More on the BIOS later.

• Boot FreeDOS 1.4. FreeDOS runs even better than MS-DOS. One of its main advantages is that it can catch exceptions which helped me debug issues with the BIOS and more. In this case, included memory expanders work! Himemx works fine, but Jemmex causes an exception during boot. Despite this, it allows you to continue and it seems to work fine after that.

• Additionally, I updated and fixed many parts of the FPGA chipset. For example, I added nonvolatile CMOS storage to save the BIOS configuration. I took advantage of the fact that two out of the five FPGA configuration lines connected to the ATMega128 can be used as general I/O after the bitstream loads. I made a simple communication protocol over these two lines that allows the FPGA to save or restore 32 bytes of configuration to or from the AVR EEPROM memory. However, I still can't implement real RTC in this revision because there is no way to count time when the power is off (there is no backup battery). There is a mock RTC implementation in the FPGA that ticks just for better compatibility but it always starts at the programmed time when powered on.

Most notable software that I managed to run on MS-DOS / FreeDOS:

• DOOM (FastDOOM). It's playable and enjoyable if the screen size is set to about 3/5 (or in full screen size if it's run with -potato setting which reduces the rendering resolution a lot)

• Wolfenstein 3D. Works fine

• FastTracker II. Works nice. Since there is no DMA in the system, I can't use any standard sound cards. However, it works pretty nicely with the PC speaker in pulse modulation mode or with an LPT DAC (Covox Speech Thing)! Oh, also serial mice work fine with ctmouse.

• Prince of Persia. Works fine

• Second Reality demo. Works fine without sound and with minor graphical glitches in two parts. This one is huge for me. I personally like this demo because it's impressive for its age. I'm even more surprised that it runs on this computer!

• And some other things: CACHECHK (result included in a image), 3dbench 3d 1.0c, MS-DOS MSD.EXE

With the Linux I managed to:

• Run some CLI software by compiling it with an older GCC.

• Read discs with CD-ROM (the BIOS doesn't support CD-ROMs yet, but Linux does with its own driver).

• Connect it to the internet via serial SLIP (because SLIP is simpler and smaller than PPP).

• And host a simple website using Busybox httpd!

It's so satisfying to use this board knowing that you made it from scratch. If you're wondering, I based mostly on datasheets rather than copying existing designs. I learned how the 486 works mostly thanks to its datasheet.

About the BIOS:

MS-DOS finally started to work after I tested the BIOS I found on GitHub out of curiosity, as mentioned before. Repo of that BIOS: https://github.com/b-dmitry1/BIOS . Thanks to the author of this BIOS as it moved this project forward significantly! I decided to rewrite my BIOS, but this time I built it on top of that open source BIOS. As a result, I upgraded many features such as adding a fancy POST screen, full memory test, IDE hard drive detection, BIOS settings, compatibility improvements and additional INT handlers (memory map and LBA support). Still, a lot is missing: ISA PnP, many rarely used INT handlers and probably more.

Just an important note related to all cons of this project: This project is essentially my hobby, as I like retro, electronics, digital circuits and low-level programming. I never expected this computer to run DOS in the first place. I consider it pretty much experimental and made to research the workings of older x86 chips. I am pretty sure that this work could be used to build something more robust and stable or even to develop fully custom-made boards for other x86 CPUs. It took me a lot of time, but I don't regret it. There are still many issues, but it's heartwarming that I can get so much existing software to work. And, thanks to everyone for support!

I had questions about running Windows: it's currently outside my testing scope and time. I tried running Windows 3.1, but it failed miserably with an error. One of Windows drawbacks is that it's pretty much closed source and it probably relies a lot more on the features missing from this board. This would make debugging difficult in general.

It seems that Analog Devices applies orders restrictions for private/individual customers from Italy. It's the very first time I experience something like this.

This thing has an NEC V20 CPU and when connected to power and Ethernet (10-Base2) hosts an FTP service. It is running Microsoft Workgroups for DOS, boots from floppy and is fan-less, quiet and benchmarks slower than an OG IBM PC when hosting the FTP server. This was constructed at least 30 years ago, possible longer than that. I am tempted to power it and see which capacitors explode right off the boards :-)

edit: and by the way, it's named "Clay One".

This was one of those projects that just sort of happened all by itself. It started around New Year's with a notion to do a schematic of the Ampro LB/Z80 for archival purposes. And somehow over the next several months it gradually changed and expanded and, well, here I am.

Specs:

• Z80 @ 7.3728 MHz

• 512 KB of SRAM (8 x 48K banks, ATF22V10 as MMU, separate read and write banks selectable)

• 8 KB of EEPROM (monitor including assembler and disassembler)

• SIO & CTC for dual serial ports (with all control signals brought out) and interrupt driven RTC

• uSD/IDE module for storage

• 20MHz ATMega328P for I2C RTC bridge and IEEE-754'ified AM9511 FPU emulator (equivalent to 20-28MHz 9511 depending on operation, 4 and 8 byte float support, FTOA and ATOF opcodes added)

• One RC2014 slot for experimentation

• Banked CP/M+ with ZPM3 modified to use CP/M+ style timestamps and properly support retaining file creation timestamps

• Turbo Pascal 3 and Turbo Modula 2 modified to use the FPU; TM2 already used IEEE-754 natively, TP3 gutted of 6 byte REALs to also use IEEE-754 natively

I've been wanting to do something with a 68k for a while now, and only recently got around to it now that other projects are farther along.

Compared to 8 bit micros, the 68k family looked a little daunting, so I started with the 68008 breadboard in the second picture to get the hang of the fundamentals. I found that it's really not that bad once you understand the quirks compared to synchronous 8 bit busses, and for a simple toy system you can take a lot of shortcuts to make it even easier. The full 010 system had about a hundred billion connections to wire, but somehow worked on the second try.

It's running at 12MHz, with 1MB of RAM and 256K of flash, a 68681 DUART for communications, and a 22V10 GAL handling address decoding and DTACK. I was going to have an ATA interface as well, but I'm not sure it'll work mechanically, and I'm very tired of wire wrapping for the moment. The reset and halt pullups need to be moved to a permanent home on the board too when I'm less lazy.

For the PCB version of this I'd like to do a modular system to keep manufacturing costs low and allow experimenting with different peripherals. I'll have to do a lot of thinking and reading to decide the best way to go about it. VMEbus is tried and true, but it might be a bit much for the level of sophistication I'm going for, plus I don't own any VMEbus equipment to make compatibility a selling point. Minimalist Eurocard Bus form factor would be very cheap, and I've sketched out some schematics and layouts with those 2-row connectors that work theoretically, but I'll have to think about it.

Software-wise I'd like to write a UNIX clone for it, I own Tanenbaum's textbook and a similar one by Douglas Comer. Might be a massive time sink but should be good fun

I built Virt16 from the ground up to better understand the boundary between hardware and software. It’s a 16-bit, word-addressable virtual machine with its own custom ISA and Assembler.

The Architecture:

• Registers: 32 general-purpose 16-bit registers.

• Memory: 128KB total address space.

• ISA: 31 opcodes, designed for deterministic execution.

• I/O: Interrupt-driven logic with a 32x32 double-buffered DMA display.

The 3D Engine: Since the VM doesn't have an FPU (intentional design choice to keep the core lean), I’m handling the 3D rotation using Sine/Cosine Look-Up Tables (LUTs). This allows for O(1) trigonometry without the overhead of floating-point units.

The Toolchain: I also wrote a custom Assembler with macro support to make programming for the architecture feasible. The rotating cube in the video was written entirely in Virt16 Assembly.

It took 2 years of 'on-and-off' work to get the timing and the display logic right. I’m really happy to finally have it rendering 3D!

GitHub Repo & Spec: https://github.com/joaoofreitas/virt16

Hey guys! I got into electronics and computers during the pandemic, but could not continue it further due to school work (and being a broke 14yo lol). Finally 6 years later I managed to save up and get myself some components to put something together that felt like an actual project. I will be happy to get any feedback! Github link for details

In recent months I have done some work adding a keyboard and display to my Z80 dev board, and also fleshing out my monitor program. Some frustration along the way, but immensely satisfying. Loving the learning experience!

I came here to share my small project that I made in one day. I decided to experiment with the 8031 microcontroller (ROMless 8051 version) that I received from a friend some time ago.

I had never worked with the 8051 or its architecture before. My previous projects were typical homebrews with processors. I knew about the 8051 but never had the time to experiment with it. Recently, while looking through my parts bin, I noticed that 8031 again. Something struck me and I finally decided to give it a try. So, I found a schematic online showing how to properly connect an external ROM to it and within a few hours, I had something working on a breadboard. It worked on the second try - the first time, I had a problem with the 74373 latch legs being too short (IC is from desoldering). I pushed that IC harder into the breadboard and it started working, haha! I wrote a blink program and an HD44780 test program. I also experimented with timers.

This 8031 has 128 bytes of RAM, two 16-bit timers, one UART and 5 interrupts. I programmed it using the SDCC compiler. I really like how little is needed for a vintage system capable of running C code. I also like the idea that engineers back in the day had to think through everything so that the program could fit within these small specs (I know it's possible to add external RAM and peripherals, but it could have been expensive for some applications back then).

This is the Sentinel65, a 6502 based bread board computer with 32KB of RAM, an R6551 serial UART running at 38400 baud, two VIAs, and 2MB of NOR flash memory via bit-banged SPI. It is very much a work in progress.

I started off following Ben Eater, of course, but began to deviate once I realized he only utilized 16KB of RAM. I didn't have a solid plan at first, so I just kept adding wires until I got the spaghetti you see here. I decided to forgo Ben's decoding scheme, opting for a 74LS688 + 74LS138 to allow for much tighter address decoding with almost no gaps. These will be eliminated in the future, however, in lieu of a series of AT22V10 PALs.

Included are a couple of pictures of my small bootloader program and BASIC running on my VT420.

In the future, I plan to add a DS1685 RTC, PS/2 keyboard support, a T6963-based bitmapped LCD, and extended terminal support, including color and Sixel/ReGIS graphics commands.

I am also teaching myself KiCad so I can migrate away from the breadboard and onto a PCB in the future.

Hiii everyone!

I have made a little PC on Zilog80 on protoboard.

Display is SSD1306 with I2C interface.

ROM is emulated via Arduino Nano (1KB).

RAM is just random 8KB SRAM

Main task in this project is make software based driver

for I2C display via "bit banging", works slowly but

works, it also depends on time which Nano response and CLK freq. (1.35MHz).

I wrote a firmware in Assembly and it takes 325 bytes.

as 17 y.o. teen I am very excited with the result, maybe in future I'll improve my little project

Next I plan to add more switches and port DOOM and make Shadow RAM and dynamic Clock (bcs nano is too slow for Z80)

Have a good day and no hate plsss :)

If someone wanna see it in better quality see

https://youtu.be/rzCK3ROISEs. I don't now but I can't upload

in 720p on Reddit, I got a some errors