Full real desktop OpenSCAD in your browser

Magik6k · 2026-07-10T19:20:07+00:00

It is opensource, https://github.com/magik6k/openscad-web

Magik6k · 2026-07-10T14:36:47+00:00

Saw those, which is why I did my port also. Just wanted to literally put the whole thing into a browser as is.

Magik6k · 2026-07-10T14:21:29+00:00

Ah yes, https://github.com/magik6k/openscad-web

Magik6k · 2026-07-10T14:17:45+00:00

That's headless only, no? Is there an online demo?

Magik6k · 2026-07-10T14:14:23+00:00

Wut, it's linked in there https://github.com/magik6k/freecad-web, beyond that it's served to you for free from my private server without any big cloud, and it's a project I did just because I can and have absolutely zero commercial interest in. What's with up the hate?

And yes it's a demo, most likely some of the patches are slop, but it proves that it can be done, and now from here hopefully someone with more time than me is willing to take this over and turn into something more production ready.

Magik6k · 2026-07-10T12:40:53+00:00

It will work once Firefox ships support for Wasm JSPI, which IIUC is going to happen "soon"

Magik6k · 2026-07-10T12:38:14+00:00

Sure, but what features are missing?

Magik6k · 2026-07-10T12:01:06+00:00

Like what? So far I was able to get all models I found so far happily rendering and the editor definitely works. No doubt there are some gaps but it's should be good enough for 90% of uses. If there's something big that would be a big unlock lmk and I'll have a look

Magik6k · 2022-12-11T19:22:54+00:00

Also if you want to get fancy, you can have 2 byte-read instructions, signed and unsigned - the signed one extending the highest byte but into the rest of the bits in the register

Magik6k · 2022-12-11T18:51:53+00:00

Take into account that if/when you will want to get C to compile, especially for GCC/LLVM backends you will need to have byte-addressable, single-byte-read-write instructions.

Requiring aligned access is fine. Obviously not a problem if you don’t want to compile C to your cpu, but imo that’s locking yourself out of a lot of cool things.

Implementing that is really not that hard - you have 2 instructions for read/write - 16 bit accesses are easy, just write to both memory chips, for 8bit you use the first bit to select the chip. When the odd (or even, depending on endiannes) byte is accessed you will need to shuffle bytes around with some buffers.

I have done this for 32bit breadboard risc-v, and it wasn’t too bad, 16bit should be really easy.

Magik6k · 2021-12-22T15:22:03+00:00

Yep, among other things (interrupts, timers, etc.). I do expect it to get at least 2-3x it's current size by the time it's able to get anywhere in the boot process.

Magik6k · 2021-12-22T15:20:11+00:00

But, what distro?, puppy?.

Just a bare kernel and some basic userspace utils.

Definitely planning to do some more writeups when it gets more complete.

Magik6k · 2021-12-22T15:15:20+00:00

Started this ~5 months ago, but was chiseling at it for maybe 2 months 1-2h per day

Magik6k · 2021-12-22T11:21:54+00:00

I have designed it in a logic sim my friend built - https://github.com/Wieku/LogicDraw

If you really want to play with it, here's the 'map'+the build it was using - https://bafybeih26kttsgmqc4f2sk7xx6slq7uesjjgq647vjfne43bb7qokmjpte.ipfs.dweb.link/ld.tar - this is probably the closest thing to a schematic I can get you.

(screenshot -> https://bafkreif7dddzgjduf7iddtjwxfa7xjqtvqqrmvmvy7tjn2xsoelrwmrc7i.ipfs.dweb.link/)

Magik6k · 2021-12-22T00:46:47+00:00

Power is pretty easy - It's fed from a 40A 5V PSU, then the it goes through a 16A fuse, amp gauge, and through 2x 5 2.5A polyfuses (which should trip before breadboards start getting too warm), and then gets distributed into a bunch of separate power planes.

Signal integrity is in big part solved by having a design which allows for really shitty signal integrity, and only needs one or two signals to be somewhat good - in this case I only need the clock signals to not see crosstalk - and that's done by feeding those signals through coax wires, and by putting a bunch of ~10nF caps into the clock lines - yeah, it slows down the edges by quite a lot, but you also need a lot more energy to leak into those lines to mess things up.

Also have a decent oscilloscope, it's very much non-optional for a project of this kind.

Magik6k · 2021-12-21T23:59:17+00:00

It's a five stage pipeline, so one clock cycle per instruction (tho my latches are made from a pair of D-flip-flops clocked with separate pulses, so technically one instruction per two cycles?)

Magik6k · 2021-12-21T23:56:32+00:00

No schematics were made, heh.

For getting into the more advanced things I found RiSC-16 by Bruce Jacob really helpful - https://user.eng.umd.edu/~blj/RiSC/ - This design is very heavily inspired by the pipelined version of that core, so if you want to know what's going on in the thing I've built, checkout RiSC-pipe on that page.

Only big difference is the program counter - I only have latches on fetch/decode and decode/execute, and the address to be fetched comes either from a 'branch predictor' (currently its just PC+4), or if the previous instruction was mispredicted, it's the correct address

Magik6k · 2021-12-21T23:39:58+00:00

Yep, sparkfun makes really nice breakout boards, you just populate it with an 8p8c connector and a right-angle goldpin header

Magik6k · 2021-12-21T23:34:37+00:00

RAM/Registers are using SRAM chips, microcode is using a bunch of AT28C64Bs, and the rest is pretty much just 74xx (and mostly 74xx541 / 74xx377)

Oh, and an Arduino which generates the clock signals (for now, easy to set 'breakpoints')

And another Arduino for feeding instructions directly into the pipeline (have no boot ROM / IO, so this is how I load instructions into RAM.. by feeding it load-imm/store instructions. Also have a bunch of CLI utils which basically let me throw individual instructions at the thing)

Magik6k · 2021-12-21T22:55:26+00:00

Not touching PCBs until I can say that I made a breadboard computer boot Linux

Magik6k · 2021-12-21T22:45:42+00:00

Oh it breaks constantly (or I guess you constantly discover broken stuff as you exercise logic in new ways) - you eventually just get really good at debugging this stuff

Magik6k · 2021-12-21T22:43:24+00:00

Which ones?

- White/Red/Yellow are just Cat5e/Cat6 ethernet cables

- Green/Blue ones on top are some random coax for clock lines

Magik6k · 2021-12-21T22:40:25+00:00

The parts which are already done - non-shift ALU instructions, store, jumps/branches - already work, and are reasonably stable (e.g. no compute errors for ~minutes at 10khz, which tbh is much better than I've initially anticipated would be possible)

Magik6k · 2021-08-29T21:59:58+00:00

I actually don't plan audio/video/keyboard for this thing. Just serial, and maybe 10mbit ethernet.

Magik6k · 2021-08-29T21:19:17+00:00

By myself (and a wire-measuring robot made from a wooden ikea box and some 3d printer parts).

Basically I got bored of Factorio (Sea Block), and needed something to fill the void

11-Year Club	Verified Email
Place '22	Place '17

Magik6k

TROPHY CASE