I’m back! Fraud Squad unbanned me so WE are all having a party at my house

Although I can’t use nano apparently anymore… so Crawssembly will be having it’s final ship very very soon

I’ve been doing much more testing and implementing the network device. Specifically testing the following commands: io net ip, io net addr, io net connect, io net socket, io net port, io net listen, io net accept, io net send, io net protocol, io net block, and io net recv.

HTTP requests working 🔥

ts is so peak icl

I’VE ACTUALLY DONE IT 🔥

Networking is now officially part of Crawssembly. Alpha tests on localhost have all passed

I’ve brought run back from the dead. You can now use run rXX  to run a binary value inside the input register as a Crawssembly instruction

stardance

I’m finally getting somewhere with the editor, however I’m now having issues with character deletion, and adding characters inside empty newlines

Still no clue why characters aren’t being saved to memory in my free heap block Slow day today fr

For some reason, I’ve been banned on slack. I don’t know why, since no one will tell me. This is not good news, but luckily it doesn’t seem to be a stardance-wide ban, so I can still do the hackathon.

Lots of work today, sorry for the . I’ve been struggling with the text editor, heap buffers, cursor allocation, character addresses, etc etc… ad infinitum. However, I’m getting close. Rendering is outputting something, although I don’t know why typing doesn’t seem to add anything…

I’ve added io keyboard mod to create a bitfield of modification key presses for the keyboard device, so now keys like CTRL and TAB can be handled, which lays the foundation for my next project which is making a basic file editor in casm

Sorry for the but it’s been a hectic couple of days. I got into University! I’ve also been busy taking a look at a CGOL implementation, truly amazing stuff! Go check it out: https://github.com/srxcode/game-of-life-crawssembly

I’ve separated the old sleep command into sleepms for millisecond waits and sleepus for microsecond waits. Although, microsecond precision is highly dependent on the OS, so it won’t be as accurate as sleepms for smaller values (Say, n<50)

I’ve merged the new fgo rules to the project, so now fgo points to labels similar to jmp, but fgo 0 now jumps to the label defined in r01 I was having some issues with using git but I got them sorted

I’m back from camping! (RIP my 60+ day streak) My plans going forward immediately is improving program counter modifications to allow for higher-level concepts to be bootstrapped onto Crawssembly instruction sets. (Image unrelated)

I’ve been working with @BetterClient to inprove the program counter and bringing back fgo from casm beta. This is also a reminder that I’ll be OOO until next Monday.

I’ve made publishing packages super easy now, all you need to do is craw init to create the package, and then craw pkg publish. As long as you’re signed into CPM and gh, it’ll just work

I’ve added Markdown support for CPM packages 🔥

@imakebloatedcode Thank you for your pr for CPM to include OpenAPI scemata, another great addition from the Craw Systems community Most of my time has been reviewing it and making small edits to include the security auth headers for API keys

Official Announcement

I’m not going to be online through the 5th August to the 10th August, I’ll be camping for those 5* days in a very low-data spot, and I’m almost certainly not taking my laptop. I might be able to get a tiny amount of code on my phone to keep my streak but certainly not enough to engage in my normal conversation on slack or post devlogs

Package creation and accounts are now working (theoretically) from the command line 🔥

The account page is looking better, and it’s survived some user testing 🙏 I need to add some boring stuff though like API key listing and said key management

I’ve been back working on CPM, focused on user accounts.

The Crawssembly community is real 🙏 I’ve been reviewing a PR on the GitHub to improve the multiplication script in the CSL (std/math/multiply.craw)

I’ve been messing around with --input tag which seems to mess around a bit in the rust vm, but I think I’m getting closer to the cause

Hack Club seems to have updated the rules on banner images, claiming it has to be an image of your project working. This is no issue for Crawssembly. The new banner is now the output of one of my programs, creating the banner pixel for pixel. This both compiles with the new rule, as it demonstrates Crawssembly functioning, while maintaining its identity.

I’ve discovered that the input file mechanism is broken, so that’s great. I’ve also been adding more commands to CrawOS

I’ve been adding some very basic commands, such as exit, help, and clear

Once you get 1 command working, many more will follow! That’s right, a command line written 100% in Crawssembly code 🔥

icl I’ve not done much today, mostly testing the allocation code and it looks up to spec tbh, not much to say

Stack allocation and freeing appear to work, but I need to do more testing to prove it

I’m still working on stack allocation, the complex parts are walking the stack properly to get the headers, along with making sure I don’t corrupt any data. The image attached shows the maximum heap block size in blue, with the data taken up by the header of that block in red (top corner)

I’m going ahead with this schema for heap blocks, the reserved bits can be used for extra features that I might want to add in later versions

Staff, please remove the time on this devlog, I accidentally left nano open all night. Sorry!

Reading user input isn’t that easy compared to a language like Python, where you can just do input(). Each character has to be processed as soon as the keyboard records a press, and then saved to memory. I’m currently working on a block method that takes every 16 character you type, and allocates a small block on the heap for each press. This is going to be used for my big project

I’ve decided to add a heap library to complement the stack library. Doing this should make my next idea easier

Please also star my actual github page! It’s more important than stardance followers 😤😤

https://github.com/Jonah-Crawford/Crawssembly

Since IEEE 754 single precision can encode much larger numbers than a standard 32-bit binary number, you can use the library to approximate much larger values for computation

I’ve been working on a IEEE 754 single precision 32-bit floating point number library for CSL, it turns out it’s more difficult than I expected!

I realised that my documentation had some issues and unfinished sections, so I touched them up

Added a simple stack library for function calls and other uses, along with some smaller graphics programs such as screen/rectangle_fill.craw

This is also my official announcement that I’ll be doing much less programming, due to summer holiday starting now. This is because I can’t program during family time, camping weeks, and other events. In addition, I have University after summer holidays, so this reduced productivity will continue throughout the rest of Stardance. Thank you all for making Crawssembly the number 1 project on stardance!

67 followers

I’m currently focusing on adding new functions to the screen library, such as rectangles, using the line program as a primitive

The initial line algo only works for the 0-octant, but now my new and improved version works for every line angle!

We have proper line segments working 🔥

I’ve been adding line functions at the moment, to be honest it’s harder than the circle! Getting the angles right is the hardest

Circle made 🔥

Taking a break from CPM to work on some graphics libraries, drawing lines, circles etc…

Accounts are going to be tricky, more front-end stuff and some complex security back-end is going to make this tricky

Thinking about user login for the CPM, might implement this soon

Thanks to @Keyboard1000n17 for making the CPM website!

I won’t be as active over the next couple of days so don’t expect many updates

I’m not good at css, but I’m trying to make the CPM website simple and easy to use. It’ll take a while but it’s slowly coming together

It turns out I was way closer than I thought! Publishing your own Crawssembly projects is now out of alpha, into beta (Because only I have an API key atm!)

Still not too much progress on CPM, but I’m still confident I can get it working

CPM is being difficult, I’ve gone through multiple iterations now of the craw pkg publish command, but I feel like I’m getting close.

I’ve been fighting with my server for a while now, the connection keeps on interrupting. As votes are currently coming in for Crawssembly v1.1.0, I suspect my score will be lower than expected due to the demo and doc websites coming offline randomly.

My issues at the moment are about getting a command, craw pkg pack to create a CPM ready tarball of your project from the command line. That and my server is having a couple of internet issues at the moment which are hindering my progress.

This devlog is also an official announcement that I won’t be as active as normal over the next week. I have family coming around so my time programming will be limited. In addition, when summer holiday starts this will continue, which is why most of my time programming is in the June and early July, the rest of stardance will have fewer updates and less time spent on casm.

CPM officially works! The pipeline of Crawssembly Source -> Tarball -> Github -> CPM -> craw pkg install -> executestd functions!

I forgot to add on the hackatime projects of my time spent on the CPM and tests, mb

I’ve registered the Crawssembly Package Manager website, some SQLite problems caused some issues but I’m getting there.

I’ve been having some internet issues with my server recently, so my productivity has slowed. However I’m at the final testing stages of linking github repos to get craw install <package> to work. The test is done on a simple repo but it should be enough to see if it works

Compiling from a local tarball works! I’ll be working on the database soon so users can search and download. My plan is that the program is stored as a github repo, similar to cargo.

Package manager is coming along… slowly. I’m still working on getting a local package to install into the global executestd file inside the home folder, but it’s taking it’s time!

v1.2.0 is already underway! I’ve spent some time constructing a cargo crate for Crawssembly to allow other rust programs to use Crawssembly’s logic. So now YOU can add Crawssembly to your programs!

After helping figure out the Stardance bug with projects, Crawssembly v1.1.0 is ready to ship!

I’ve added the compare branch, for number checks. ==, !=, >, >=, <, and <= all included

I’ve added more CSL files, such as math/power.craw, math/abs.craw, and math/modulo.craw

Basic multiplication and division are the first to enter the CSL! I focused on making them memory efficient rather than time efficient, because using fewer registers makes it easier for beginners to use them in normal programs. And because Crawssembly is very very quick (Almost C level speeds) a couple extra thousand ticks won’t be missed for these first programs

File execution is now working! You can insert programs using execute path/to/program.craw, this leads to the Crawssembly Standard Library, a collection of useful programs that can be accessed using executestd program.craw, such as multiply or division code.

I’m going to confess here, I was a bit lazy. I decided that, because I could create the time program, I rewarded myself by adding a native ISO 8601 time output command io text iso rXX. Elegant? Yes. Low-Level? Not as much as I would like. But the choice was either make a single line of code to simplify programs like this massively, or wire in a tediously made, messy 350 line program that doesn’t fully account for the 400 leap year rule or leap seconds. Hmm…

TLDR; I caved to simplicity. But CrawFS file listing from boot now display file genesis time!

The time program finally works! I wrapped it in a loop so it reloads every 200ms to make a real-time clock. Soon I’ll port it to the CrawFS system to read file creation dates

It turns out that time resolution is much harder than I thought! It’s taken me a while but I’ve got the program working for CCYY-MM-DD

CrawFS reading is almost done, but I need to program a way to take a raw Unix timestamp and convert it into a nice iso 8601 format (CCYY-MM-DD HH:MM:SS) for the ‘Time created’ field

Reading a specific file is clearly much harder than reading the boot sector. It turns out that parsing user input is a devious task itself!

Did someone say boot sectors? That’s right, Crawssembly can now read CrawFS boot sectors and output the file table data! This took a surprisingly long time, as the binary boot sector is very delicate.

I’ve been working on a basic file system, CrawFS, used as a stepping stone towards real ones like FAT16, FAT32, and NTFS.

No time to waste after v1.0.0 is released! I’ve added raw disk sector editing for Crawssembly; an opt-in way of reading and writing to your real disk, rather than a VM.

! THIS COULD DESTROY YOUR COMPUTER !

So only do it if you know what you’re doing, as a single bit change will probably brick your entire machine if you use the --raw-disk option

The final updates have been made, the github is ready to ship!

THIS IS IT!

The moment I’ve been waiting for almost a year, the first stable release of Crawssembly v1.0.0! And what fortune that I get to share it with you people on Stardance!

Crawssembly is soon to be shipped on version 1.0.0! A massive milestone for a project I started ~11 months ago. The raffle discs have been burned, and final preparations are underway for release.

Basic syntax highlighting for nano! Simply run craw install-nano to gain access to these beautiful new colours when editing .craw files.

RAFFLE UPDATE!

The 3 discs have been completed. Soon, Crawssembly will be shipped on it’s first release! Remember to follow Crawssembly before the 1st July 00:00 UTC for your chance to win one of these beautiful pieces of computing history!

I’ve been working on fixing up the activities in the README.md, and providing possible solutions for each. The image below is a possible output of the activity “Smiling Screen”

Adding the last features for pong was quite simple, making the computer lag behind a random amount utilises the current millisecond UNIX timestamp, with the least significant 2 bits being used as the ‘reaction time’, along with a per-frame flag to increase this reaction time to solve for repeating loops. The scoring system at this point is just the number of pixels in the top corner, unlike the real pong which used numbers. Perhaps for a later version?

PONG is very almost finished, all that needs to be done is to fine-tune the computer movement and finish displaying the score.

I’m now moving onto some game examples. I’m working on a basic version of the popular game PONG, the hardest part is going to be the graphics syncing up with the mathematical logic

The structure of the compiler is complete, but getting it to work is another beast of debugging. I think this is the first program of its kind; the first program where no one, not even me, can understand it fully. A true milestone for Crawssembly

Integer parsing requires multiplication by 10, which in Base-10 is easy as you can just add a zero at the end. But in binary you can’t do this, as that would be multiplying by 2. So you need to get a bit more creative when multiplying by a known amount in binary.

The code below shows how a number, ‘abc’ can be expressed as 100a + 10b + c. This is real code from my Crawssembly compiler written in Crawssembly.

I’ve done a little experiment with a reduced branch of Crawssembly made for tiny ISA’s, with instructions only a single byte wide! An image of what the CPU’s core might look like is shown below.

The trie is complete! Although I’ve still much to do for the compiler, such as per-character parsing, storage of label elements, calculation of register codes, etc…

7/24 trie branches have been added to the compiler, totalling just under 1000 lines of Crawssembly code, the longest hand-written .craw program ever made!

Adding branches still takes a while, but it’s much more efficient than testing every character for every instruction. So far I’ve mapped 17 out of ~64 command strings.

I’ll be taking a break over the weekend, as I’ve just completed my final exams and I’m celebrating. I’ll be back proper on Monday.

Today I worked on creating a trie for Crawssembly’s commands, which can be used to increase efficiency in my compiler to parse instructions faster. Rather than checking every char for every instruction like

cal add -65 r01                ; if r01 = 65, this will be 0
ifz 10                         ; continue if 0
    cal add -70 r02            ; if r02 = 65, this will be 0
    ifz 20                     ; continue if 0
        etc...

I can split each branch into separate instructions, reducing line count and time-to-compile

Basic structures are coming together for the compiler

The C emitter function now works to the same standard as Crawssembly Online!

In other news, I’m starting to write a Crawssembly compiler in Crawssembly! This is a big step and proves that Crawssembly’s language is comprehensive enough to take on this task.

I’m working on a way to convert Crawssembly into native ASM language, by writing to a C file and compiling that output.

ATTENTION! The moment has arrived; The CRAWSSEMBLY Raffle!

Get the chance to win a LIMITED-EDITION installer and collectable Crawssembly Disc!
The disc contains the official compiler, virtual machine, and documentation. Also included are un-released legacy files from development. Simply follow Crawssembly on Stardance to enter your name!

Shipping may vary depending on the UK Postal service. There are 3 physical First Edition discs available worldwide. If you’re outside the UK, I may ask you to contribute towards postage if shipping costs are high.

The 3 winners will be announced on the 1st of July! So get your entry in before 23:59 UTC 30th June! Don’t miss this opportunity! Follow Crawssembly today and support open-source learning!

I want to thank the Stardance devs for my Super Star tag! Peak staff fr

Random number generator has been added to the example group, I used XOR and bit shifts with the new command io time milli, which extracts the current UNIX timestamp in milliseconds, as the seed. Basic, but quite random from a human perspective.

I’ve been working on some examples, the biggest one being a simple calculator.

Graphics bug fixed! Crawssembly for macOS is officially working!

File input now works for macOS Crawssembly! Run craw myprogram.craw --file myinputs.file to run! (The image is from Linux, not from my Mac because it’s too old for me to log in to stardance and post a ss from it, but I can assure you it works!)

macOS can now do everything windows can except use the speakers, scan-line free graphics, and access files. These will be the largest source of my time.

I’m currently working on getting macOS support running. At the moment, macOS is only confirmed to work to the same level as Crawssembly Online. Hopefully I can get it to the same standard as Linux and Dos systems!

My respect to real CPU designers, this is tricky work! The most difficult thing is working with the 256 different registers, that’s lots of wiring to get done.

Dedicated documentation website created, and the new demo is live at https://crawssembly.ultimatecraw.xyz/

Demo and README in working order, for real this time!

The final things to do before shipping:
Full macOS functionality: Maybe
Add documentation to demo: Yes
Add syntax highlighting to demo: Maybe
Final Cleanup: Yes

I don’t usually work with frontend, so the demo won’t look anywhere near as nice as some of the other projects on Stardance, but as long as it’s usable then I’m happy.

Crawssembly demo now working! Luckily it wasn’t as hard as I expected. I’ve tied it to an old URL for now, and it’s basic, but it works.

https://demo.ultimatecraw.xyz/

README.md Complete! The final steps is creating the demo! (And maybe getting MacOS working)

Many thanks to Koy Camerini-Yachdav, who tested Crawssembly on Mac OS! Their efforts go towards helping more people understand how computers actually work. ❤️

In other news, Crawssembly is soon ready for the first official release. I estimate <2 weeks before a ship fully working on both Linux and Windows systems will be made!

File inputs are finally ready, I think craw now has all it needs for the first release. Exciting times!

README.md now has documentation about all commands that will be in the first release. I’m yet to make the live demo and the documentation about machine codes though!

Crawssembly Programs can now be force-quit by pressing CRTL+C. I should have added this long ago, but I added it in the end.

I’ve been doing some user testing, and have made changes to the documentation and program, such as adding craw myfile.craw --dump-decoded and craw myfile.craw --tui commands easy to use and run.

Dynamic graphic size achieved! You can now set the screen size of the Crawssembly program by running craw myfile.craw --screen WIDTHxHEIGHT using the –screen argument.

README.md now contains enough information about Crawssembly to make it Turing Complete. The rest involves storage, input devices, and output service commands.

Crawssembly is officially clear for Windows & Linux OS releases! Mac OS support will hopefully come soon. There may be some linux distros that are special and cause some weird and wonderful problems, but for the generic versions (Think Ubuntu) I’m confident that Crawssembly is compatible.

Never understood what binary actually is? Why is it important, and why are binary skills becoming less important? All this, and more, is revealed in the Crawssembly Project; the ultimate guide to learning the fundamentals of real computer design, and assembly-like languages.

More work done on the docs today. I’m assuming near-zero knowledge about computing to allow all to access the Crawssembly Project

Most of my efforts today are going to the README.md file, helping beginners get their heads around Assembly-like languages

Currently working on adding logical branching (‘if’ statements) to CRISP, my high-level language to compile into Crawssembly

Crawssembly - Initial Post