What even is fakebit?

To me, fakebit is an aesthetic. It’s similar to demakes and “real chiptune” but without the limitations that come to that. I throw away the “realness” of the hardware to create something that sounds exactly how I want. That is the point, that is intentional. It sounds like it could be chiptune but it’s refined, without limits. I like the term to describe this likely because I create both, so having a term to separate my stuff that is made within the limits is very useful for me.

When fakebit is this, It’s deeply creative, everything you make is a homage to your love to that sound and style, it’s fake in the same way that fake fur is, Able to emulate the look and feel, but without needing to use the real thing.

It seems like, to many others, especially outsiders, fakebit has become a rallying cry to “call out inauthentic” works, a means to elitism. A value judgement. They don’t understand that the limitations are not the art.

What even is this argument then?

The argument is that fakebit harms chiptune because it’s inauthetic. The idea that it makes the really wild things people have managed to get out of the hardware look less amazing, and at the same time make the really bad examples look more common and easy.

The truth is, it is more difficult to make something that sounds good in the limitations of hardware. Their argument is because it’s not real hardware, real limitations, it’s not real art Q.E.D. That “fake art” thus, harms “real art”.

I don’t agree with this at all. There is more than one way to make art, and not all of the output ever put out on the hardware was art either. For every Tim Follin putting out rad prog rock on the hardware, there was another programmer just making it play a public domain song (or sometimes just stolen melodies) to make the game have music. It simply being on the real hardware doesn’t make it good.

What is true of the harm.

Back when “8-bit” was a bit of a massive thing everywhere. There certainly was a lot of people trying to put out 8bit covers and demakes and post them to YouTube to maybe get popular. I remember in that space, “fakebit” vs chiptune was a huge thing because people were creating and upload awful midislaps² to release tons of these to YouTube and hope they built a following.

But the harm of midislap songs actually go far beyond fake chiptune, you see it in every single genre and style. Think back to those low effort “techno remix” or the current mess of eurobeat and bardcore remixes. When your goal is to chase whats popular, make content to make money…

It’s a deeply cynical reason to create, channels like that still create today. They don’t care if the thing sounds right or wrong, they don’t even care if people comment on the thing to tell others that it’s fake. They care about the view and the engagement. Your negative comment is just as good for them as someone getting “tricked” and thinking that this is what “real chiptune” sounds like.

Why do people care about the limitations?

As always, whenever there is people calling out this kind of thing, be it plagarism, ai art, or midislaps, people take away, and give the wrong argument towards this kind of thing. The argument becomes performative, no longer is it calling out that the art was done cynically… it becomes that they didn’t use the right tool to make their cynical trash. As has happened with the retro game revival, it’s now all about authenticity of the tools, not the authenticity of the purpose.

Art, Writing, Music… the general person doesn’t really understand how these things really work. How things are made. When it comes to electronic music and digital art, people tend to hyperfixate on the tools, of the trade, much like they did with the traditional forms of these before. A guitarist is a god because they put the work into learning how to move their fingers just right on the fretboard and strings, A painter is a genius because they learned how to mix the paints on the palette just right to get the perfect texture… How do you reconcile this with digital work that you don’t understand? Clearly the limitations MUST be the art otherwise what separates them from everyone else.

oh god you’re gonna make it about capitalism now.

Capitalism has taught so many people that the arts are like pro sports. that things they perceive as easier literally makes doing it that way inauthentic or cheating.

That’s the wrong way to think about art, but I understand. When you see someone making something “just for the money” with as low effort as possible, it sucks. You don’t need to bring anything in but that though. Instead of questioning if something sucks because it’s not using the right limitations, ask if it’s really that it’s a low effort money grab.

conclusion

Chiptune has always been loose in what it meant, it’s only much more recent that folks started to separate “fakebit” from chiptune. Some of the earliest things called chiptune or chipmusic was literally just a soundalike, made with samples on the amiga. While I absolutely accept that words change meaning, this style has always been part of it.

I don’t agree that we should banish the word fakebit, it clearly has worth, there are dozens of musicians you can find on soundcloud and youtube that unironically use the term to describe their own music. Instead I think the right take is to say, loudly, fakebit is good actually, as time goes forward there is no point to keep ourselves stuck to the old hardware. Limitations are not a thing to stay static, creating music that sounds like it’s from soundchips has never been easier, with furnace tracker³ as well as VSTs and DAWs that are actually within reach by normal people.

Thanks and Other thoughts.

Thanks to Zia for reading over and giving me a “+1” response.

Thanks to FreeFull for reading over and reminding me the fact that chiptune/chipmusic’s definition has changed over time.

I wish that the YouTube algorithm didn’t fool people into watching videos on topics by people who aren’t part of that community. The video that caused this from what I’ve heard from two people who are… is honestly pretty awful.

Systems/Desktop Programming

Perhaps I made a bit of a huge mistake undertaking a project where I have to handle fake times in rust. It’d have been an annoying project in C too, but nonetheless, My systems programming project was a timekeeper for my RPG sessions. My goal was simple, but I feel it really taught and showed me the holes in my understanding.

Documentation, mathematics vs programming

You have to know what to ask, where to look, and what you’re actually looking for to find a lot of the documentation in rust. The documentation is right there but its hard to find. Using a community discord might be a good option but that’s really not for me¹.

For me? my first real wall was trying to find out how to do integer modulo and floor. Both of these are fairly simple questions to answer if you know where exactly to look. As someone who’s been coding rust for… not even a week… That was not me, In the end venting about this on my discord’s #tech channel was what got me the right answer.

These are easy questions so why were they so hard to answer? Because I didn’t know two key important things

• rust doesn’t always call things the same thing that standard programmer convention does.
• rust std documentation often has the info, you need to really search it first and assume what you are looking for exists.

If I had known these two things going in, I wouldn’t have gotten frustrated. I would have just found the things. Instead I used a search engine, like I think most people do when trying to find documentation for a language. This was painful, the game Rust, and rust being a fairly quickly moving target made this much more difficult than other languages.

The modulo operator % is a great example of where rust doesn’t use a typical programmer convention, This is described as the “remainder” operator. This is mathematically correct, % in other languages is really remainder too. If you need a real modulo that handles negative numbers correctly, you have to write your own. Thing is, I don’t think most programmers actually know the difference². When I searched for info on rust modulo… I got posts telling me rust didn’t have one built in, not “Rust implements % just like C, as a remainder function.” or recognising that typical bit of convention at all. This ended up confusing me immensely. Compiler errors I got implied % didn’t exist (see the next section on compiler errors for more on that front), but it was actually that both sides needed to match. Blog posts and stack overflow implied modulo didn’t exist unless you implemented it. I was about ready to give up there.

The .floor() method is a great example of knowing where you need to read the docs. If you search for it in a typical search engine, you end up getting a rather old crate³. If I had known it was a method for f32 and f64 and i should search the docs for it instead of looking for a math.floor or floor() function, I would have known exactly what documentation to look for, This is quite a chicken/egg problem.

The compiler errors are not as clear as evangelists think they are.

Rust evangelists often praise the compiler errors and warnings as being a “killer feature”. The thing is, They still suffer from the same problems as any LLVM compiler does. You will get confusing errors that you cannot solve by just reading it. Over time you will familiarise yourself with certain kinds of errors, you will learn what it means despite what it says. You are not the same as a new programmer.

A new programmer won’t understand why ? causes a type error the first time it comes up. A new programmer may not understand what they are doing wrong with the mod keyword. Even as you work through the book. Only with making every single possible mistake can you understand what you did wrong, often including having to search an error because it makes no sense. The errors I’ve seen so far that do make sense? those are often the same kinds of errors that LLVM based compilers like clang actually catch too.

This isn’t really a fault of the compiler, compilers don’t know what you mean, they can make some assumptions and try to be helpful but in the end, if they could do what you mean, without you clarifying by fixing your code, they would just have done it in the first place.

Crates for everything, stable APIs be damned.

In rust, nearly everything you could possibly want is a crate. This isn’t a bad thing per say, I come from perl and everything there is a perl module and uploaded to CPAN. What’s scary is the amount of things that you would think are included as a helper… but aren’t. Basic things like unix signals (to catch SIGTERM for example) are relegated to crates instead.

Crates have features, you can read something and not enable a required feature, Serde and Clap but have a derive feature that has to be enabled, the examples don’t always make it clear this may require a feature flag or an additional module. This was actually a cause of a lot of the compiler errors that made no sense.

Crates seem to be a moving target that hurts to follow. I mentioned i started with a book this time, in that book we learned to use clap. What it did was pretty neat, a programmatic method of handling args for your program. It does still do this. The thing is, the API changed a while ago, and they only promise not to change the api every 6-9 months. I had to relearn how to use it. While this problem is not unique to Rust it does seem to be a common issue I’ve noticed as clap wasn’t even the only one that did this.

extern, libc, and reality

Talking with someone who jumped on the rust train earlier than most has taught me one massive thing. The hypetrain around rust often doesn’t reflect reality. A good example of this is the “rust std completely 100%ly replaces libc” lie. This is only true on no-std targets, and even then you might be linking your own C stuff for that. It makes sense when you think about it, If you were required to use rust for everything, rust would be far less useful. The ability to interop with libraries and programs written in C and C++ is one of the things that makes it compelling.

It’s nice that I can use things like libc or Qt or ncurses. These are mainstays of development in a world that has been doing GUI computing in the mainstream for a good 40 years. We have tools that work, and moving away from them will be a more difficult reality than allowing us to use what we already got. People are even still using openssl with rust. They probably shouldn’t be, but nonetheless it is there and ready to use.

Web Programming

I did not poke at rust for web programming. I will use Elixir or Ruby for this pretty much always. It’s what fits my use cases the best and I see no point using a language like rust for this. I know rust has been seeing use in this space, perhaps if I find myself liking it further on down the line I might experiment with something that isn’t fast enough or is too memory intensive in elixir or ruby. Doubt it though. This section is here mostly to address this “blind spot” for the reader.

Embedded Programming [Microcontrollers]

Rust on my microcontrollers for the most part became a bit of a nonstarter. While I found countless modules for every single chip, I didn’t find HALs that were still in development for what I have. Rust feels quite incomplete in this space, people will say “but there is a crate for that”, but a concerning amount of times it’s just a svd2rust conversion without a HAL. Due to this lack of hardware, I ended up writing no code and looking at and compiling examples.

I was rather interested in rust on esp8266, it was one of the situations I saw rust doing very well in. The problem is, I don’t have time for “experimental” code for my projects. When I saw that the ESP8266-hal crate had been moved on from to focus on the ESP32 stuff. I have no problem with focusing on the ESP32, I just don’t own one and didn’t want to source one for experimenting with rust.

The amount of code it does generate is quite impressive, It’s about on par with C, that said I did not have a quite a fair test because the C I had on hand to compare it was for a different more complex mcu. I couldn’t find examples and code for the EXACT boards I have in rust either [well, that didn’t use C as well], and I didn’t really get to see if it’d flash and it’s real size…

Ending Thoughts

I can see how and why people like rust. My opinion on it is softened but I don’t see myself reaching for it first. I can see its potential. I’m going to keep my eye on it, and maybe with some age and time… things will be less in a state of flux.

Thanks to the rustaceans I sent my drafts to to catch factual errors. If you find a factual error (read: not an opinion) that is not related to an updated version of rust in this post, You can try get ahold of me and I’ll probably fix it. I probably won’t update this beyond a few months due to the moving target-ness beyond saying things may have changed in a minor version.

This post is part of a series: Previous Article

Rust in Action does seem to be a bit better about this, even admitting in the “cons” section about the rust hype that lead to me digging in so hard to anti-rust. However it does still reek of the rust missionary scent. It sometimes feels unrealistic in recommendations such as with recommending rust for microcontrollers after admitting language size as a con. I do like that it leans into reminding you that rust is not a panacea for all bugs though.

A downside of Rust in Action is the errors. Every book will have errata, it’s just a reality of writing. Every book will also have things that just go out of date, but some of the errors are VERY obvious and should have been caught before publication. Errors like code that won’t compile, examples that are just plain wrong.

Lets actually talk about language and syntax now. What do i like:

• The promise of pattern matching
• The promise of higher-order functions
• deeper type-safety
• Immutability by default
• cargo fmt
• Templates/Generics

I mostly write in functional programming languages, and elixir at that, for the majority of projects I write these days. I also used to write a lot of typed Racket. These features in a language actually designed to be useful would be killer.

Things I dislike so far:

• no dynamic casting for Number (or at least integer) types

  In my opinion, you shouldn’t have to cast numbers as other numbers, the compiler could cast smaller datatypes to bigger datatypes (of the same datatype). I understand wanting users to be direct in what they want but, this is a little over the top IMHO. I shouldn’t have to ask it nicely at the very least to treat a u16 as a u32. That said, I can understand having to ask it nicely to treat a u16 as an f16.

• cargo’s use of TOML

  It’s a mostly small nitpick, but I… really dislike TOML. if i wanted something like ini, which I don’t, I’d use ini. I don’t know what I’d replace it with exactly for rust, I’m a bit spoiled with elixir and mix I think.

• first order functions don’t work exactly as expected.

• do we… really need unwrap() everywhere?

  okay so elixir has the same concept in some ways, but we tend to do it with something like {:ok, thingwewant} = called_function instead, maybe using some guards as well. I just find .unwrap() at the end of many lines to be supremely ugly

That said, I dislike the language far less than I did last time around. Sort of surprised, This is not at all what I remembered it being like when I was playing around with those pre-1.0 builds. I still don’t know how it plays in the realms that I tend to work in though.

This post is part of a series: Previous Article Next Article

While I doubt that I will find myself liking rust this time around, I think in doing this I can at least better explain myself better.

Why I haven’t liked rust

It didn’t even run where I needed it to run

So if there is anything I am somewhat known for, it has got to be my freebsd fangirling. A previous version of this site had it front and centre. My hostcloak on freenode before the fall was freebsd/lover/alliefox… and rust didn’t run on freebsd. It test suite wouldn’t pass, it could compile without a standard library and that’s about it. On top of that a lot of projects that I’ve had since are embedded projects for micro-controllers like the msp430. Rust’s code size was much larger than C’s and this was a problem, it wouldn’t fit in the tiny micro-controllers we had specced out for the project.

I don’t like it’s optics

Everything around the language is all about how the language makes “safety” easy, and coming from a C perspective and an infosec perspective, I find that claim infuriating because memory safety errors while common, are not the only kind of error in existence, and errors in logic can be far more damaging.

In the earlier days there was also this aura of unearned elitism as well. It couldn’t run everywhere, almost nothing of value was written in it (which in many ways can still be said today.) and yet people were acting like it was already the best thing ever made and was changing everything.

I don’t like it’s (~ version 0.8.0) structure

I found rust back when I last used it to be somehow both very terse and very verbose. Additionally, the push to throw more stuff into the compiler through macros was a “bad code smell” to me as someone who was writing C and C++. I felt like “wasn’t this exactly the kind of thing they complained about us doing?” whenever i saw a !, It always felt too clever, and clever code was never a good thing.

I don’t like it’s fans

Rust users have this annoying tendency to essentially recreate everything, and ask you why you aren’t using rust. This gets very annoying, especially if you are primarily a C programmer. But they aren’t the worst, they in the end are still programmers, the worst are the people who don’t even write code, they just hear through the aforementioned optics I mentioned, that rust is better in every way, even in places where rust at the time DIDN’T EVEN RUN.

Why I became so hostile.

I didn’t start out hostile. I actually was very interested in the language during 0.7.0~0.8.0. I wrote a script that continuously tried to build it’s patches until tests passed on my servers (which ran FreeBSD). This lasted about a month without ever passing. I tried to learn it with a build on my linux box, and I found the syntax clear as mud.

I put it down and just went back to doing what I normally did at the time, C and Perl, and didn’t think much about it for a long while. It grew. Suddenly I’m getting asked in IRC chats when talking about projects why I’m not writing them in rust, and there is a refusal to take “it doesn’t run there” as an answer.

I got tired of seeing take after take about how people who write in C and C++ are the problem, and the world would be better if everyone would just switch to rust. Ignoring the fact that still, at the time, rust did not run on most micro-controllers. I started digging in deeper and deeper, every single time I saw something like that. OpenSSL being OpenSSL caused a massive amount of these as it still does to this day.

Kari: Honestly, I feel it says more about OpenSSL than it does about C, but asking people to stop using OpenSSL is literally impossible

Today it’s just all of these feelings swirled together. I find it hard to not stubbornly stay in this space. It’s been literal years of refusing to try it again.

Why I don’t think I’ll like it

For rust to really blow my mind and for me to love it, It has a heck of a task ahead of it. These days I don’t program as much anymore, and when I do I’m working in Elixir. I’ve grown an appreciation for C++ working on a couple of projects of a partner of mine’s especially with Qt.

We as a whole like languages where the code we need to write just flows like water from our mind. Everything we’ve seen of rust code doesn’t seem to be that and likely would cause us deep frustration instead.

But we will try, and even more difficult, we will try to open our mind a bit instead of stubbornly refusing it.

This post is part of a series: Next Article

The kind of guy that was sardonic, probably drunk, and took glee in shitting on anything and everything and just making everyone miserable.

23:00 < newbie~>: hey i made this, i think its pretty cool! :D
23:01 <+that guy>: Here is all the reasons its bad, you're shit and you should feel bad.

This guy was everywhere on IRC, there were usually multiple ones of these guys on every single IRC channel everywhere, and they were just part of the “vibe” of every single one.

Something I’m starting to realise is that I’ve slowly been becoming one of these guys. I see elements of that kind of behaviour everywhere, especially in how I handle discussions around technology. It’s like every ounce of joy and excitement about tech has been stolen away. I don’t even realise I’m doing it.

IRC put this in my head as a right way to act. The same kind of people are ostensibly the reason that IRC died for anything but tech discussions. It seemed on IRC, the right way to be a hacker was to be the person most able to shit on everyone else.

I need to remove this behaviour from myself, seeing it in myself has made me realise just how toxic it is and how toxic I can be as a person. It wasn’t okay, and it isn’t okay that I perpetuate it. I can hide behind the fact I was bullied in school, I can say it’s just part of how I grew a “thicker skin”. It’s not, it’s toxic behaviour, I just became a bully like everyone else, it doesn’t matter that it was done to me first.

This is not

• a tutorial blog
• a tech first blog
• journalism
• a sanitised view of us

Posts about tech stuff will often focus more on the journey we took to get to the result than the code. While we recognise the need for tutorial posts, we’re not interested in that.

Technology has been becoming less and less intersting to us, and while there is absolutely going to be posts about tech, we really don’t want to be seen as “a tech blogger” or a “games blogger”. Thats such a narrow intersection of our interests.

We’re not a journalist, what we write will be deeply based in opinion. Nothing we write should be taken as hard fact. Draw your own conclusions and think for yourself. Check and Verify.

We’re tired of hiding who we are. We want to be the queer, plural, disabled, mad furry kin that we are on the internet. We see no reason to hide it anymore. Be mad.