Maxine Alexander

Does anyone know the normal way of taking a bunch of wat (wasm text) files and merging them into one file? Currently using the c-preprocessor with include directives, but I'd really prefer something cleaner, and the performance isn't the same as just using imports/exports afaik.

#wasm #webassembly

A screenshot of regex101.com, with a very long regex string and a sample text to run the regex on.

Hot take: regex is an esoteric programming language.

es·o·ter·ic
/ˌesəˈterik/
Intended for or likely to be understood by only a small number of people with a specialized knowledge or interest.

And yes, regular expressions are programs!

#software #programming #regex

A screenshot of a bug report for picotron

A screenshot of a bug report for picotron that includes assembly from picotron's decompiled source

Think this bug report is overkill?
Nahhhhhhhhhhh, probably not.
www.lexaloffle.com/bbs/?tid=148...

#picotron #pico-8 #reverseengineering #decompilation

Block Block Block Block Block

A screenshot from a draft of Pastel's datasheet that reads: Chapter 1. Introduction In order to properly document Pastel, its usage, and how it works, we must first understand what Pastel is. The problem with that though is that Pastel isn’t one thing. In fact, Pastel can be described as 4 separate (but interconnected) layers of a tech stack: 1. A fantasy hardware platform 2. A fantasy computer / video-game console 3. A fantasy operating system 4. A fantasy desktop environment Each of these 4 things are described as “fantasy”. But if you’re here reading a datasheet, what does that mean? Surely it cannot mean that Pastel is fictional, since you’re here learning to use it. Because there is a lot of confusion to be had for anyone not familiar with how the term is used here, and to get everyone on the same page, let’s define “fantasy” more formally. 1.1. What Does “Fantasy” Mean? In this context, “fantasy” describes any system that is self-consistent and usable, but not physically manufactured or limited to existing commercial hardware. A fantasy platform may define entirely novel hardware, instruction sets, or operating environments, so long as those definitions are internally coherent and executable in software. Most “fantasy consoles” are creative playgrounds; they are constrained virtual machines designed to evoke the feelings often associated with retro hardware and encourage artistic expression. They prioritize ease, simplicity, quick iteration, and aesthetic charm over deep simulation or system fidelity. Pastel fits the fantasy definition quite nicely, given that it’s not a physical device you can buy, and its software stack is purpose-built for its environment. But we weren’t content with simply recreating the feeling of old hardware. Instead, we want Pastel to simulate not only the idea of a console, but define and enforce the complete system architecture of one. Text was cut short by alt-text length limit, apologies.

A continuation of the introduction: 1.2. What Is Pastel, Anyways? Now that we’ve defined fantasy, let’s discuss how the term applies to individual components of Pastel’s tech stack. Because Pastel has multiple levels of both hardware and software, we’ll go from lowest level to highest. 1.2.1. A Fantasy Hardware Platform Implemented in silicon or software, Pastel has a lot of hardware to talk about! We have multiple CPU cores, a cache hierarchy, hardware-enabled virtual memory, shared system memory, a GPU, and more! When discussing how being fantasy affects the hardware of Pastel though, we’re aiming for the answer “it doesn’t” as much as possible. Even though the hardware is all implemented in software, the goal is for that to be functionally irrelevant. When considering the “how” of hardware constraints in a software implementation, the system bus comes to mind. It could be left as an abstract metaphorical construct with various system components talking directly to each other. And in any other project where realism and depth aren’t the explicit goal, it very probably would. Pastel, however, cannot; waiting on bus access for data transmission across the system isn’t just for realism— it was the core limitation of the Nintendo 64 console. Because several components run in parallel, a Mutex is a convenient method for simulating bus contention and control acquisition. Following that, any given bus interface must be locked as well. If a CPU core wants to “talk to” the memory controller, a lock must be acquired on the CPU bus interface, then a lock must be acquired on the bus, then a lock must be acquired on the memory controller’s bus interface. That’s a simplified explanation of the process, but illustrative enough of the parallels between acquiring mutex locks and bus contention and control acquisition.

An image describing the hardware components and layout of Pastel. Among these are the Lunar core, which runs Lua bytecode, and the POWER core, which runs wasm bytecode. 1.2.1.1. Key Hardware Features Key features of the hardware platform include: - 32-bit System (registers, bus width) - Lunar Core @ TBD MHz - POWER Core @ TBD MHz - System Core / “Hardware”-implemented Kernel Subroutines @ Native Clock Speed - Bytecode Compilers (first-class language support for the following) - Lua - luac - teal - picotron - WASM - c/c++ - rust - Pastel Shader Language (PSL) - Virtual CPU Caches - L1 Data: TBD KB (Lunar + POWER + System) - L1 Instruction: TBD KB (Lunar + POWER) - L2 Shared: TBD KB - Exclusive inclusion, so total cache area is L1D*3 + L1I*2 + L2 - Hardware Support for Virtual Addressing - 16MB RAM (expandable with cartridges) - DMA Controller - Memory Controller - Descriptor Engine - Coherency Engine - Interrupts/Events - Graphics Core - TBD KB tMEM - PSL Microcode Runtime - TBD KB dMEM - TBD KB iMEM - OpenGL Passthru (OGLP) - Audio Module - TBD - Peripherals - Cartridges - Can extend hardware - Game carts extend hardware by providing extra storage (where the game data exists) - 4 MB address-space each, maximum - Drivers are loaded from the boot sector of each cartridge - Distribution Format: TBD - Up to 16 Carts can be used at once

An early draft to the intro section of Pastel's datasheet!

#pastel-pfp #fantasyconsole #retrogaming #lua #wasm #rustlang

It was fun reading about caches and figuring out coherence, hierarchy, and various policies. For Pastel it looks like I'll be going with an exclusive inclusion policy that uses a swap procedure for evictions on a cache-miss. Mostly because I don't really want gigantic caches.
#pastel #fantasyconsole

Did someone say high-fidelity fantasy desktop?

#pastel #fantasyconsole #lua #wasm #rustlang

Pink PCB with purple nails

Drying purple nails with hot air

Making my key personality traits pink PCBs, soldering and my nails

pronouncing 'escorts' like 'esports'

I know a *lot* of guys who are badly wanting to *do something* to help.

May I suggest:

Go into federal establishments and ask "Why don't you have non-gendered restrooms??"

Check first or not, whatever. Let a bit of pressure out this way. Do some menti hell. Go on hon, you can do it!

Moving around

A screenshot of Maxine's IDE, split down the middle vertically. On the left is the source markdown for documenting a struct for the Peacock framework, on the right is the rendered form of the source on the left.

Currently focusing on a documentation update for peacock non its core libraries! Enjoying writing it!

#software #rustlang #rust-lang #peacock-rs

I wanted the performance of retained-mode without being a PITA to use, and without pretending to be something it isn't (again, such as Dear ImGUI)

</response>

it seems rather complex to maintain. And if you aren't doing that, your immediate-mode library is redrawing every frame, which really isn't idea (imo). This does tend to make retained-mode kind of a PITA (looking at you, iced) but that's why peacock exists!

I see I see. Mostly performance! There are libraries that have an immediate-mode interface but are actually retained-mode (such as Dear ImGui), but I've never been particularly satisfied with that approach. While it leverages the ease-of-use of immediate-mode with the performance of retained-mode...

yea! It's pretty neat! :D

I think it's interesting that you went with an immediate-mode framework. Care if I ask what led to that decision? I chose to use iced specifically because it's a retained-mode library. I also had a fairly limited number of options when looking for a retained-mode library.

A screenshot of some source code using the Peacock framework to create a button that counts the number of times it has been clicked and then updates its text content to display that count.

I'm having fun developing peacock's examples :3

#software #rustlang #rust-lang #peacock-rs

yup! I wasn't satisfied with how tedious iced was to use, even when you're doing something very basic. So I started development on peacock! I had to write my own css parser (crest) and its performance is pretty dang good! very happy with progress so far :D

peacock is a GUI framework I've been developing. It uses XML for structure, CSS for style, and Rust for behaviour :D

It's not quite ready for production apps, but it's well on its way to beta!

A screenshot of a terminal running cargo commands for Peacock, a rust-based GUI framework that uses XML for structure, CSS for styling, and Rust for behaviour. Also included in the screenshot is some source code for an example Peacock application.

Some pre-alpha testing of peacock! In the process of a rewrite to make the code much cleaner!

Still need to implement the rest of the widgets, add event subscriptions, and add support for applying CSS stylesheets (courtesy of crest) to widgets.

#software #rustlang #rust-lang #peacock-rs

The Phantom Tollbooth is an isekai.

You're welcome.

A screenshot of a terminal with tests and general info on Crest, as well as performance benchmarks comparing Crest to LightningCSS.

Crest is coming along VERY nicely! I recently added support for arbitrary css properties (they just receive no validation whatsoever) and optional values for css properties! Pretty happy with performance this early too! Acid tests are going great!
#software #rustlang #rust-lang #peacock-rs

it's already open-source! it's just not ready. While it functions, it currently does not support real-world usage.

A screenshot of a terminal displaying performance benchmarks of lightningcss and crest

So this is pretty crazy (crest is a custom css parser I've been working on)
#rustlang #rust-lang #software #peacock-rs

pest is a rust crate specifically, but I'm sure you could find a PEG library/package for other languages just as well!

I don't know what you're referring to, but "Drop Pop" is a "parody" account. It's a made-up headline. Not that I think this is funny 😒

extra reading:
en.wikipedia.org/wiki/Parsing...

pest.rs/book/grammar...

pest is a rust crate for generating a parser from a PEG (grammar) file. The grammar file is what I sent a screenshot of. The PEG returns a token stream with data such as token type, start vs end, location, that sort of stuff. I have to validate the token stream, and it's kind of a PITA lol

A screenshot of a PEG grammar file for the pest crate for rust, used to describe the CSS language, with grades for each rule on how well that rule complies with the CSS syntax standard.

A snippet, though validation of token stream orders is the hard part, you can't get very complex in PEGs, unfortunately

may she send all the help. I'm working on a CSS parser as a core library for a project I'm working on and it's.... well, it's damn hard.