#Calculate Linux

[piratesexmachine420]

[skyeqt]

I wrote a quine, without strings, in a calculator

Okay so I should probably clarify some things, the calculator in question (dc) is more of a "calculating tool", it is built into most linux distributions, and it is a command line tool. I should also clarify "without strings", because dc itself does support strings, and I do actually use strings, however, I do not use string literals (I'll explain that more later), and I only use strings that are 1 character long at most.

So first of all, why did I decide to do this, well, this all started when I found a neat quine for dc:

[91Pn[dx]93Pn]dx

If you're curious about how this works, and what I turned it into, it'll be under the cut, for more technical people, you can skip or skim the first text block, after that is when it gets interesting.

So first of all, what is a quine, a quine is a computer program that outputs its own source code, this is easier said than done, the major problem is one of information, the process of executing source code normally means a lot of code, for a little output, but for a quine you want the exact same amount of code and output. First of all, let's explain dc "code" itself, and then this example. Dc uses reverse polish notation, and is stack-based and arbitrary precision. Now for the nerds reading this, you already understand this, for everybody else's benefit, let's start at the beginning, reverse polish notation means what you'd write as 1+1 normally (infix notation), would instead be written as 1 1 +, this seems weird, but for computers, makes a lot of sense, you need to tell it the numbers first, and then what you want to do with them. Arbitrary precision is quite easy to explain, this means it can handle numbers as big, or as small, or with as many decimal points as you want, it will just get slower the more complex it gets, most calculators are fixed precision, have you ever done a calculation so large you get "Infinity" out the other end? That just means it can't handle a bigger number, and wants to tell you that in an easy to understand way, big number=infinity. Now as for stack based, you can think of a stack a bit pile a pile of stuff, if you take something off, you're probably taking it off the top, and if you put something on, you're probably also putting it ontop. So here you can imagine a tower of numbers, when I write 1 1 +, what I'm actually doing is throwing 1 onto the tower, twice, and then the + symbol says "hey take 2 numbers of the top, add them, and throw the result back on", and so the stack will look like: 1 then 1, 1, then during the add it has nothing, then it has a 2. I'm going to start speeding up a bit here, most of dc works this way: you have commands that deal with the stack itself, commands that do maths, and commands that do "side things". Most* of these are 1 letter long, for example, what if I want to write the 1+1 example a little differently, I could do 1d+, this puts 1 on the stack (the pile of numbers), then duplicates it, so you have two 1s now, and then adds those, simple enough. Lets move onto something a little more complex, let's multiply, what if I take 10 10 * well I get 100 on the stack, like you may expect, but this isn't output yet, we can print it with p, and sure enough we see the 100, I can print the entire stack with f, which is just 100 too for now, I can print it slightly differently with n, I'll get into that later, or I can print with P which uhhhh "d", what happened there? Well you see d is character 100 in ASCII, what exactly ASCII is, if you don't know, don't worry, just think of it as a big list of letters, with corresponding numbers. And final piece of knowledge here will be, what is a string, well it's basically just some text, like this post! Although normally a lot shorter, and without all the fancy formatting. Now with all that out of the way, how does the quine I started with actually work?

From here it's going to get more technical, if you're lost, don't worry, it will get even more technical later :). So in dc, you make a string with [text], so if we look at the example again, pasted here for your convenience

[91Pn[dx]93Pn]dx

it makes one long string at the start, this string goes onto the stack, and then gets duplicated, so it's on the stack twice, then it's executed as a macro. In technical language, this is just an eval really, in less technical language, it just means take that text, and treat it like more commands, so you may see, it starts with 91P, 91 is the ASCII character code for [, which then gets printed out, not coincidentally, this is the start of the program itself. Now the "n" that comes afterwards, as I said earlier, this is a special type of print, this means print without newline (P doesn't use newlines either), which means we can keep printing without having to worry about everything being on separate lines, now what is it printing? Well what's on top of the stack, oh look, it's the copy of the entire string, which once again not coincidentally, is the entire inside of the brackets, so now we've already printed out the majority of the program, now dx is thrown on the stack, which as you may notice is the ending of the program, but we won't print it yet, we'll first print 93 as a character, which is "]", and then print dx, and this completes the quine, the output is now exactly the same as the input. Now, I found this some time ago, and uncovered it again in my command history, it's interesting, sure, but you may notice it's not very... complicated, the majority of the program is just stored as a string, so it already has access to 90% of itself from the start, and just has to do some extra odd jobs to become a full quine, I wanted to make this worse. I started modifying it, doing some odd things, which I won't go into, I wanted to remove the numbers, replacing it entirely with calculations from numbers I already have access to, like the length of a string, this wasn't so hard, but then I hit on what this post is about "can I make this without using string literals"

Can I make this without using string literals?

Yes, I can! And it took a whole day. I'll start by explaining what a string literal is, but this will largely be the end of my explaining, from here it's about to get so technical and I don't want to spend all day explaining things and make this post even longer than it's already going to be. A string literal is basically just the [text] you saw earlier, it's making a string by just, writing out the string. In dc there's only 1 other way to make a string, the "a" command, which converts a number, into a 1 character string, using the number as an ASCII character code. Strings in dc are immutable, you can only print, execute, and move them around with the usual stack operations, you cannot concatenate, you cannot modify in any way, the only other things you can do with a string, is grab the first character, or count the characters, but as I just explained, our only way to make strings creates a 1 character string, which cannot be extended, so the first character is just, the entire thing, and the length is always 1, so neither of these are useful to us. So, now we understand what the restriction of no string literals really is (there are more knock on restrictions I'll bring up later), let's get into the meat of it, how I did it.

So I've just discussed the way I'll be outputting the text (this quine will need text, since all the outputting commands are text!), with the "a" command and the single character strings it produces, let's now figure out some more restrictions. So any programmers reading this are going to be horrified by what I'm about to say. If I remove string literals, dc is no longer Turing Complete, I am trying to write a quine in a language (subset) that is not Turing Complete, and can only output 1 character at a time**. You can't loop in dc, but you can recurse, with macros, which are effectively just evaling a string, you can recurse, since these still operate on the main stack, registers, arrays, etc, they can't be passed or return anything, but this doesn't matter. Now I cannot do this, because if I only have 1 character strings via "a" then I can't create a macro that does useful work, and executes something, since that would require more than 1 command in it. So I am limited to only linear execution***. Now lets get into the architecture of this quine, and finally address all these asterisks, since they're finally about to be relevant, I started with a lot of ideas for how I'd architect these, I call these very creatively by their command structure, dScax/dSax, rotate-based execution, all-at-once stack flipping, or the worst of them all, LdzRz1-RSax (this one is just an extension of rotate-based execution), I won't bother explaining these, since these are all failed ideas, although if anybody is really curious, I might explain some other time, for now, I'll focus on the one that worked, K1+dk: ; ;ax, or if you really want to try to shoehorn a name, Kdkax execution, now, anybody intimately familiar with dc, will probably be going "what the fuck are you doing", and rightly so, so now, let's finally address the asterisks, and get into what Kdkax execution actually means, and how I used it.

*"Most commands are 1 character long, but there are exceptions, S, L, s, l, :, ; and comparisons, only : and ; are relevant here, so I won't bother with the rest, although some of the previous architectures used S and L as you may have seen. : and ; are the array operations, there are 256 arrays in dc, each one named after a character, if I want to store into array "a" I will write :a, a 2 character sequence, same for loading from array "a" ;a, I'll get into exactly how these work later **I can only output 1 character at a time with p, P, and n, but f can output multiple characters, the only catch being it puts a newline between each element of the stack, and because I can only put 1 character into each stack element, it's a newline between each character for me (except for numbers). I'll get into what this means exactly later ***I can do non-linear execution, and in fact, it was required to make this work, but I can only do this via single character macros, which is, quite the restriction to put it lightly

So I feel like I've been dancing around it now, what does my quine actually look like, well, I wanted to keep things similar to the original, where I write a program, I store it, then I output it verbatim, with some cleanup work. However, I can't store the program as strings, or even characters, I instead need to store it as numbers, and the easiest way to do this, is to store it as the char codes for dc commands, so if I want to execute my 1d+ example from before, I instead store it as 49 100 43, which when you convert them back to characters, and then execute them in sequence, to do the same thing, except I can store them, which means I can output them again, without needing to re-create them, this will come in handy later. So, well how do I execute them, well, ax is the sequence that really matters here, and it's something all my architectures have in common, it converts them to a character, then executes them, in that order, not so hard, except, I'm not storing them anymore, well then if you're familiar with dc, you might come across my first idea, dScax, which, for reasons you will understand later, became dSax, this comes close to working, it does store the numbers in a register, and execute them, but this didn't really end up working so well. I think the next most important thing to discuss though, is how I'm outputting, as I mentioned earlier "f" will be my best friend, this outputs the entire stack, this is basically the whole reason this quine is possible, it's my only way of outputting more characters from the program, than the program itself takes up, since I can't loop or recurse, and f is the only character that outputs more than 1 stack element at once, it is my ticket to outputting more than I'm inputting, and thereby "catching up" with all the characters "wasted" on setup work. So now, as I explained earlier, f prints a newline between each stack element, and I can only create 1 character stack elements, and because in a quine the output must equal the input, this also means the input must equal the output. And because I just discovered an outputting quirk, this means my input must also match this quirk, if I want this to be a quine, so, my input is limited to 1 character, or 1 number, per line, since this is the layout my stack will take, and therefore will be the layout of my output. So what does this actually mean, I originally thought I couldn't use arrays at all, but, this isn't true, the array operations are multiple character sequences yes, but turns out, there actually are multiple characters per line, there's also a linefeed character. And since there is an array per ASCII character, I am simply going to be storing everything in "array linefeed"! So now, with all of this in mind, what does the program actually look like.

Let's take a really simple example, even simpler than earlier, let's simply store 1 and then print it, this seems simple enough, 1p does it fine, but, lets convert it to my format, and it's going to get quite long already, in order to prevent it getting even longer, I'll use spaces instead of newlines, just keep in mind, they're newlines in the actual program

112 49 0 k K 1 + d k : K 1 + d k : 0 k K 1 + d k ; K 1 + d k ; 0 k K 1 + d k ; a x K 1 + d k ; a x

now, what the fuck is going on here, first of all, I took "1p" and converted both characters into their character codes "49 112" and then flipped them backwards (dw about it), then, I run them through the Kdkax architecture. What happens is I initialise the decimal points of precision to 0, then, I increment it, put it back, but keep a copy, and then run the array store, keep in mind, this is storing in array linefeed, but what and where is it storing? Its index is the copy of the decimal points of precision I just made, and the data it's storing at that index, is whatever comes before that on the stack, which, not coincidentally, is 49, the character code for the digit "1", then I do the same process again, but this time, the decimal points of precision is 1, not 0, and the stack is 1 shorter. So now, I store 112 (the character code for p), in index 2 of array linefeed, now you may notice, the array is looking the exact same as the original program I wanted to run, but, in character code form, it is effectively storing "1p", but as numbers in an array, instead of characters in a string. I then reset the precision with 0k, and start again, this time with the load command, which loads everything back out, except, now flipped, the stack originally read 49 112, since that's the order I put them on, the top is 49, the last thing I put on, but after putting them into the array, and taking them back out, now I'm putting on 112 last instead, so now the stack reads 112 49, which happens to be the exact start of the code, this will be important later. For now, the important part is, the numbers are still in the array, taking them out just makes a copy, so, this time I take them out again, but rather than just storing them, I convert them to a character, and then execute them, 49 -> 1 -> 1 on the stack, 112 -> p -> print the stack, and I get 1 printed out with the final x. Now this may not seem very significant, but this is how everything is going to be done from here on out.

So, what do I do next? Well now's time to start on the quine itself, you may have noticed in the last example, I mentioned how at one point, the stack exactly resembles the program itself, or at least the start of it, this is hopefully suspicious to you, so now you may wonder, what if my program starts with "f" to print out the entire stack? Well, I get all the numbers back, i.e. I get the start of the file printed out, and this will happen, no matter how many numbers (commands) I include, now we're getting somewhere, so if I write fc at the start of my program (converted into character codes and then newline separated) then I include enough copies of the whole Kdkax stuff to actually store, load, and execute it, then I can execute whatever I want, and I'll get back everything except the Kdkax stuff itself, awesome! So now we come onto, how do I get back the "Kdkax stuff", and more importantly, what are my limitations executing things like this, can I just do anything?

Well, put simply, no, I cannot use multicharacter sequences, and I actually can't this time, because it's being executed as a single character macro, I don't have a newline to save me, and I just get an error back, so okay that's disappointing. This multicharacter sequence rule means I also can't input numbers bigger than 1 digit, because remember, the numbers get converted into characters and then executed, and luckily, executing a number, just means throwing it on the stack, so I'm good for single digit numbers. Then in terms of math (I know, this is a post about a calculator and only now is the maths starting), I can't do anything that produces decimals, since the digits of precision is constantly being toyed with, and I also can't use the digits of precision as a storage method either, because it's in use. I can actually use the main stack though! It's thankfully left untouched (through a lot of effort), so I'm fine on that front. Other multicharacter sequences include negative numbers, strings (so I can't cheese it, even here), and conditionals.

So it was somewhere around here, I started to rely on a python script I wrote for some of the earlier testing, and I modified it to this new Kdkax architecture when I was confident this was the way forwards. It converts each character into a character code, throws that at the start, and then throws as many copies of the store, load, and execute logic as I need to execute the entire thing afterwards. This allows me to input (mostly) normal dc into the input, just keeping in mind that any multicharacter sequences will be split up. So now I can start really going, and I'll speed up from here, effectively, what I need to do, is write a dc program, that can output "0 k", then "K 1 + d k :" repeated as many times as there are characters in my program, then "0 k" again, then "K 1 + d k ;" repeated just as many times, then "0 k" again, then "K 1 + d k ; a x" also repeated just as many times, without using strings, multicharacter sequences, loops, branches, recursion, any non-integer maths, with a newline instead of a space in every sequence above. Doable. The program starts with fc, like I mentioned, this prints out all the numbers at the start, and leaves us with a clean stack, I'll explain in detail how I output the "0 k" at the start, and leave the rest as an exercise to to the reader. I want to do this by printing the entire stack, so I want to put it on backwards, k first, k is character code 107 in decimal, and I can't input this directly, because I can't do anything other than single digit numbers, so maths it is, here I abuse the O command, which loads the output base, which is 10 by default, and I then write "OO*7+a", which is effectively character((10*10)+7) written in a more normal syntax, this creates "k" on the stack, and then I can move onto 0, for which I write "0", since a number just puts itself on the stack, no need to create it via a character code, I can just throw it on there, keep in mind this will all get converted to 79 79 42 55 43 97 48, but the python script handles this for me, and I don't need to think about it. The stack now reads "0 k" and I can output this with f, and clear the stack, I then do the same deal for "K 1 + d k :", the next "0 k", "K 1 + d k ;" but here I do something a little different, because I want to output "K 1 + d k ; a x" next (after the "0 k" again), I don't clear the stack after outputting "K 1 + d k ;", and instead, I put "a x" on the stack, and then use the rotate stack commands to "slot it into place" at the end, this is a neat trick that saves some extra effort, it makes printing the "0 k" in between more difficult, but I won't get into that. For now the important part, is the output of my program now looks something like this "(copy of input numbers) 0 k K 1 + d k : 0 k K 1 + d k ; 0 k K 1 + d k ; a x" this is amazing, this would be the correct output, if my program was only 1 character long at this point, now keep in mind I'm writing non-chronologically, so my program never actually looked like this, but if you're following along at home you should have this at this point:

fcOO*7+a0fcaO5*8+aOO*7+aOO*aO4*3+aO4*9+a355**afcOO*7+aOO*aO4*3+aO4*9+a355**af0nOanOO*7+anOanOO*2O*+aOO*3-a08-R08-Rf

definitely longer than 1 character, you might think at this point, it's just a matter of spamming "f" until you get there, but unfortunately, you'll never get there, every extra "f" you add, requires an extra copy of the store, load, execute block in the program, so you're outpaced 3 to 1, so what do you do about this? You print 4 at once! I want the stack to look like "K 1 + d k : K 1 + d k : K 1 + d k : K 1 + d k :" and similarly for the other steps, and then I can spam f with greater efficiency! This was somewhat trivial for the first 2, but for the ax, because I'm using the rotate to push it at the end, I need to do this 4 times too, with different rotate widths, not too hard. And now, I can finally get there, but how many times do I spam f? Until my program is exactly 3/4s printing on repeat, which makes sense if you think about it, and below, is finally the program I ended up with

fcOO*7+a0fcO5*8+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*8+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*8+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*8+aOO*7+aOO*aO4*3+aO4*9+a355**affffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcOO7+a0fcO5*9+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*9+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*9+aOO*7+aOO*aO4*3+aO4*9+a355**aO5*9+aOO*7+aOO*aO4*3+aO4*9+a355**affffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0nOanOO*7+anOanOO*2O*+aOO*3-a08-R08-ROO*2O*+aOO*3-a082-R082-ROO*2O*+aOO*3-a083-R083-ROO*2O*+aOO*3-a084-R084*-Rffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

I say finally, but this is actually pre-python script! The final program I actually ended up with will instead be included in a reblog, because it really needs its own cut. But anyway, this was how I wrote a quine, for a calculator, without using string literals.

[pc-freedom]

Calculate Linux：企業向けに最適化された Gentoo ベースの高性能 Linux ディストリビューション

Calculate は、Gentoo Linux をベースとした高速で機能的なユーザーフレンドリーな Linux ディストリビューションです。最新性と安定性の最適なバランスを保ち、最新バージョンのアプリケーションと安定したバージョンのライブラリを提供します。Calculate Linux はローリングリリースディストリビューションであるため、システムを一度インストールすれば、ハードウェアの寿命が尽きるまでアップデートすることができます。 Continue reading Calculate Linux：企業向けに最適化された Gentoo ベースの高性能 Linux ディストリビューション

[flooferland]

I find kernel level anti-cheats and generally client-side anticheats like BattleEye, EasyAntiCheat, and Vanguard really stupid, because they really aren't stopping cheaters, all they're doing is discouraging them while sacrificing performance, user privacy, Linux support, and generally risking accidentally banning casual user.

I started developing my own anti-cheat for a game and it hit me, you should never have any anti-cheat on the client. All anti-cheats should be server-side, because to this day players are still figuring out ways to bypass these anti-cheats, like using hardware-level exploits which are physically impossible to detect unless they start serving anti-cheats as AI-powered robots that are physically in your room looking at you while you game.

Think about it.. Wall hacks let you see other players through walls, easy solution right? Just don't tell the client where the other players are, do server-side calculations for occlusion, you already have a system for it to do it client-side since it saves performance not to render players that aren't on the screen. But nope, because it would slightly increase server costs, even if it makes cheating impossible to perform.

The number one rule in multiplayer is "NEVER TRUST THE CLIENT UNDER ANY CIRCUMSTANCE", and these huge game dev corporations are consistently not following it, then complain about having cheaters while going "Oh, it must be the Linux users!!! Not our flawed approach at anti-cheat!!!"

[demifiendcruithne]

for anyone moving from windows i would personally recommend gnome because of gnome extensions being so easy to use and even just dash to panel making it look more like windows for familiarity there's a firefox extension to be able to browse/modify extensions/settings through firefox like its own extensions and honestly i don't even know how else one would install extensions because it's so simple and intuitive to do that obviously sometimes the OS updating can outdate extensions but it even just. tells you 'hey this is outdated' on the extensions list rather that not telling you like so many things on windows

for people who pomodoro and such work for there's definitely extensions for that, there's easy pi-hole access, so many indicators, virtualbox easy access, shutdown timer, as well as multiple cultural/regional (not sure of right word) time indicators like chinese lunar calendar, islamic prayer times, hebrew/iranian/nepali calendars/dates, or even just starting the week on whichever day instead of the default

though i will also say that i haven't USED any other desktop environments (with the possible exception of my old netbook with a kid-friendly version of mint), so it's very possible that KDE and such have similar! i just have no intent currently to switch from gnome because i know what i have on here and how i have it set up. lots of nice qol things like dash to panel and clipboard manager and colour picker and mpris label and gsconnect my beloveds

I don't think people realize how absolutely wild Linux is.

Here we have an Operating system that now has 100 different varieties, all of them with their own little features and markets that are also so customizable that you can literally choose what desktop environment you want. Alongside that it is the OS of choice for Supercomputers, most Web servers, and even tiny little toy computers that hackers and gadget makers use. It is the Operating System running on most of the world's smartphones. That's right. Android is a version of Linux.

It can run on literally anything up to and including a potato, and as of now desktop Linux Distros like Ubuntu and Mint are so easily to use and user friendly that technological novices can use them. This Operating system has had App stores since the 90s.

Oh, and what's more, this operating system was fuckin' built by volunteers and users alongside businesses and universities because they needed an all purpose operating system so they built one themselves and released it for free. If you know how to, you can add to this.

Oh, and it's founder wasn't some corporate hotshot. It's an introverted Swedish-speaking Finn who, while he was a student, started making his own Operating system after playing around with someone else's OS. He was going to call it Freax but the guy he got server space from named the folder of his project "Linux" (Linus Unix) and the name stuck. He operates this project from his Home office which is painted in a colour used in asylums. Man's so fucking introverted he developed the world's biggest code repo, Git, so he didn't have to deal with drama and email.

Steam adopted it meaning a LOT of games now natively run in Linux and what cannot be run natively can be adapted to run. It's now the OS used on their consoles (Steam Deck) and to this, a lot of people have found games run better on Linux than on Windows. More computers run Steam on Linux than MacOS.

On top of that the Arctic World Archive (basically the Svalbard Seed bank, but for Data) have this OS saved in their databanks so if the world ends the survivors are going to be using it.

On top of this? It's Free! No "Freemium" bullshit, no "pay to unlock" shit, no licenses, no tracking or data harvesting. If you have an old laptop that still works and a 16GB USB drive, you can go get it and install it and have a functioning computer because it uses less fucking resources than Windows. Got a shit PC? Linux Mint XFCE or Xubuntu is lightweight af. This shit is stopping eWaste.

What's more, it doesn't even scrimp on style. KDE, XFCE, Gnome, Cinnamon, all look pretty and are functional and there's even a load of people who try make their installs look pretty AF as a hobby called "ricing" with a subreddit (/r/unixporn) dedicated to it.

Linux is fucking wild.

[soup-mother]

so it turns out pressing the calculator button on my laptop keyboard makes linux mint open 160 calculator apps and crashes. awesome!

[pancakeke]

i have a bunch of fucking bookmarks for guides and calculators for making geodesic domes and parabolic antennas. also for backyard fire pits and foundries. also guides and software for making SLA printed lenses and a couple on microwave kilns (don't seem too safe tho!). Also spinning unconventional fibers, woodworking, NAS supplies and guides, bunch of stuff for turning my downstairs into an arcade. um a bunch of unorganized links for landscaping and hugelkultur. looks like I was learning linux stuff here but never mind that. bunch of recipes. historical clothing references and patterns for sewing. raspberry pi stuff. bunch of links to guides and manuals from when I was ripping my dishwasher apart and cleaning/fixing it. one single macrame tutorial lol. upholstery guides. looooots of stuff about plants and materials for building terrariums. and this is just my mobile bookmarks.

[vanesa]

How I Customize Windows and Android

Windows: Rainmeter

Rainmeter Skins

Rainmeter | Deviantart

r/Rainmeter

Rainmeter is where I get nifty desktop widgets (skins). There are a ton of skins online and you can spend hours just getting caught up in customizing. There are clocks, disk information, music visualizers, weather widgets*, and more.

I get most of my skins from the links I posted, but they are by no means the only resources for Rainmeter skins. r/Rainmeter and Deviantart have some awesome inspiration.

This is what my desktop looks like right now:

Dock: Dock 2 v1.5

Icons: icons8 - this is probably the best free resource for icons I know of

"Good Evening [name]": Simple Clean

Clock: Simplony

* Note about weather widgets: Older Rainmeter skins that use old weather APIs will likely not work. The Rainmeter forums has information with lists of weather skins that do work.

Windows: Useful Things for Workflow

Flow Launcher - this is basically a search bar, app launcher, and even easy-access terminal all in one. The default hotkey is Alt+Space. I use this almost primarily to do quick calculations. There are a ton of plugins and I've barely scratched the surface with how I use it.

ShareX - This is my screenshot tool and I love it. Admittedly, I find it difficult to configure, but once I had it set up, I didn't really have to adjust it. You can create custom hotkeys to screenshot your entire screen, or to select your screen, or even use OCR. This has saved me a ton of time copying over text in images and making it searchable.

Bonus - Get Rid of Windows Web Search in the Start Menu: If you're comfortable with editing your registry, and you want to get rid of the pesky web results in Windows search, this fix is what I used to get rid of it.

Android: Nova Launcher

This is my main Android launcher that I've been using for almost as long as I've owned a smartphone, and it's super customizable. The best part is that it's free with no ads, and you can purchase premium at a one-time cost.

The main things I use it for are app drawer tabs, renaming apps, hiding apps, and changing the icons.

I've had premium for so long that I've forgotten what the features were, but looking at the website, the one feature I use is app folders.

This is what my phone homescreen and app drawers look like:

Time/Weather: Breezy Weather

Calendar: Month: Calendar Widget (I got this on sale for like 30 cents once but there are a plethora of good calendar apps out there)

Icons: Whicons - White Icon Pack

Advanced Customization

Further things to enhance your customization experience to look into include:

Flashing a custom Android ROM (e.g. LineageOS)

Give up on Windows & install Linux instead (Ubuntu is a good one to start with)

Android app modification: ReVanced apps (includes Tumblr), Distraction Free Instagram

Miscellaneous notes under the cut:

None of these links are affiliate links. These are all tools I happen to use on a daily basis and I'm not being paid to promote them.

Install Rainmeter skins and programs I recommend at your own risk. Before altering Windows, such as editing the registry, make sure you have everything backed up.

The Windows web search fix works on my Windows 11 machine. I don't know if it works for Windows 10, but I do know I was able to disable it in Windows 10 at some point, so your mileage may vary.

Install non-Play Store apps at your own risk. (Although in my opinion, open source APKs are less sketchy than some apps on the Play Store...) Always check where you're downloading APKs form!

The wallpaper for my desktop and phone are custom wallpapers I made myself.

(At the request of @christ-chan-official)

[memedical-attention]

I’ve been thinking about this for a little while — something I’d want to do if I had the time and money would be to design a Motorola 68000-powered tiny (10” or smaller) laptop. Modern CMOS 68K implementations are very power-efficient and decently well-suited to handheld and portable devices (see: TI-92 series), and if combined with a crisp, modern monochrome OLED display, could get you days of continuous usage without needing a recharge! Add a few megabytes of RAM, some peripherals (IDE/CF controller, ISA or S-100 slots, DMA controller, SPI bus, RS-232 port, SD or CF slot, PS/2 port for a mouse, text mode + hires monochrome video card, etc…), and you have a nice, flexible system that can be rarely charged, doesn’t require ventilation, and can be just thick enough to fit the widest port or slot on it.

The main issue would be software support: nearly all existing operating systems that ran on a 68K were either intended for very specific hardware (Classic Mac OS, AmigaOS) or required more than a flat 68000 (NetBSD, Linux, or any other UNIX requiring MMU paging). So, it would probably end up being a custom DOS with some multitasking and priv level capability, or perhaps CP/M-68K (but I don’t know how much software was ever written for that — also, it provides a “bare minimum” hardware abstraction of a text-mode console and disk drive). A custom DOS, with a nice, standard C library capable of running compiled software, would probably be the way to go.

The software question perhaps raises another, harder question: What would I use this for? Programming? Then I’d want a text editor, maybe vi(m) or something like that. OK. Vim just needs termcap/(n)curses or whatever to draw the text, and not much else. That’s doable! You’d just need to provide text-mode VT100 emulation and termcap/curses should “just work” without too much issue. I like writing C, so I’d need a compiler. Now, I’m assuming this simplistic operating system would be entirely written in a combination of assembly language (to talk to hardware and handle specific tasks such as switching processes and privilege management and whatnot) and C (to handle most of the logic and ABI). I could probably cross-compile GCC and be good to go, aside from handling library paths and executable formats that don’t comply with POSIX (I have no intention of making yet another UNIX-like system). Hopefully, most other command-line software (that I actually use) will follow suit without too much trouble. I don’t know how much work it is to get Python or Lua to a new platform (though NetBSD on the 68K already supports both), but Python (or Lua) support would bring a lot of flexibility to the platform. Despite me being a Python hater, I must admit it’s quite an attractive addition.

What about graphics? All the software I’ve mentioned so far is text-mode only, yet historical 68K-based systems like the Mac and Amiga had beautiful graphics! Implementing X11 would be a massive pain in the ass, considering how much it relies on UNIXy features like sockets (not to mention the memory usage), and I really don’t want Wayland to have anything to do with this. I guess I’d have to roll my own graphics stack and window manager to support a WIMP interface. I could copy Apple’s homework there: they also made a monochrome graphics interface for a M68K configured with a handful of MiB of RAM. I could probably get a simple compositing window manager (perhaps make it tiling for a modern vibe ;3). Overall, outside of very simple and custom applications, functionality with real software would be problematic. Is that a big problem? Maybe I want an underpowered notebook I can put ideas and simple scripts down on, then flesh them out more fully later on. An operating system allowing more direct access to the hardware, plus direct framebuffer access, could yield some pretty cool graphing/basic design utility.

I’d need a way to communicate with the outside world. An RS-232 UART interface, similar to the HP-48 calculator (or the TI-92’s GraphLink, only less proprietary) would help for providing a remote machine language monitor in the early stages, and a real link to a more powerful (and networked) machine later on. I think real networking would defeat the purpose of the machine — to provide a way to remove yourself from modern technology and hardware, while retaining portability, reliability, and efficiency of modern semiconductor manufacturing techniques. Giving it a CF or SD slot could provide a nice way to move files around between it and a computer, maybe providing software patches. A floppy drive would be amazing: it would provide a way to store code and text, and would be just about the right storage size for what I want to do. Unfortunately, there’s not really a good way to maintain the size of the laptop while sticking a 3.5” (or worse, 5.25”) floppy drive in the middle of it. To my knowledge, 3.5” floppy drives never got thin enough to properly fit with all the other expansion slots, socketed components, and user-modifiable parts I’d want. A completely solid-state design would likely be the best option.

Anyway, uhh… I hope this made some semblance of sense and I don’t sound insane for going on a rant about building a modern computer with a 1979 CPU.

[unidentifiedfuckingthing]

whats up with how on windows a file cant be opened at all if a program is using it but on linux you can do whatever you want. like what is windows doing and is linux not doing it for a calculated reason or just because its simpler

[elite-amarys]

AN IDIOTIC STRATEGY. OUR CLEAR BODY PREVENTS STAT REDUCTIONS.

QUERY: HOW DO WE RAIN RIGHTEOUS PUNISHMENT DOWN UPON OURSELVES?

[vhouatroph]

hi ive been working on my gag calculator for unm

there's a couple big things lots of people will care about, and then a couple big things only a few people, or maybe just me will care about.

the biggest thing the most people will care about is custom gags, i think this is the only gag calculator that allows for users to input a gag with a custom amount of damage, which i think is pretty cool!

ive also started using github actions to build releases rather than my own hardware (since my laptop running windows died and i currently cant otherwise make a windows executable lol) which also allows me to make executables for operating systems besides windows, and throw them in releases.

so i can now make macos executable releases! i cant actually test them myself because i don't have a mac, but in theory i think they should work! one fear is that pyinstaller's automatic codesigning is not good enough and it doesn't let you run the program without turning off security features, which wouldn't look good in the readme LOL

github actions also lets me automatically build and publish the python package versions as well, so those will now be cross platform and update beyond 4.2.0, which is nice. so sorry to the 3 people who use the python package it isn't up to date 😭

the python packages also let you run the command "tt-damage-calculator" in your terminal to open the calculator now instead of "python -m tt_damage_calculator" which i think is pretty cool

ive also been playing with arch linux for the past week or so, and pushed a dev build of the calculator to the AUR, so maybe i'll start using that as another way to distribute the calculator besides pypi and the executables, just in case anyone uses arch.

the entire program was recently recoded into a more object oriented format over the past few months. this is like the fifth major rewrite ive done of the calculator, and hopefully the second to last. i kind of want to drop tk in favor of a nicer gui builder, like qt or something. but that's something for the future.

the latest dev version of the calculator with all this stuff is at https://github.com/Vhou-Atroph/TT-Damage-Calculator/releases/tag/V4.3.0_dev.4 if you like executables, https://github.com/Vhou-Atroph/TT-Damage-Calculator/actions/runs/9149820048 if you like wheels, and https://aur.archlinux.org/packages/tt-damage-calculator if you're an arch user. it has stuff for unm, so it's not really usable on the live server, but it still has some cool features i'm proud of and wanted to talk about lol

[16naughts]

Dev Log Mar 14 2025 - What's Taking so Long?

The Steam Deck version of Crescent Roll is moving along. The full game is playable, most of the audio issues have been resolved, but there's still the very slight teeny-tiny issue of WebKit being abysmally slow and we're sitting at only 10% CPU usage and 20FPS. Joy. We can fix it though. Without having to switch Web Browsers. I explained a bit before that the two options available for Web embedding are either Chromium/Chrome or WebKit/Safari, depending on your platform. Windows, Android and Xbox all have Chromium natively for you to use, Mac, IPhone, PlayStation, and Nintendo have WebKit, and then Linux and therefor Steam Deck don't have a standard one installed. We went with WebKit for Steam Deck because it's 200MB instead of 1.5GB and we have to bundle it with our game. When I said we can fix it, it's not that the actual game part of Crescent Roll isn't optimized - we actually did a pretty good job with all of the movement on-screen every frame - but there's some very specific things large surrounding it that we know are hurting performance considerably. Here a visualization of the call stack of a random average frame on the Main Menu from the Chrome profiling tools from my 10-year old i7-4770k machine:

The grey "Task" bar is the full length of the execution. The brown-yellow underneath are what run during the actual "Animation Frame" portion, then the Blue sections are Crescent Roll code, and Green is Phaser rendering code. So in this frame, it took 4.16ms for the full frame, of which, Crescent Roll used about 1.8ms to do its stuff, then Phaser took 1.5ms to do the render, and the remaining ~0.8ms was system stuff like GC and doing memory transfers to the GPU. 60Hz refresh rate would mean that you need to render in under 16 ms, so about 4ms for Windows Desktop means that I could theoretically get somewhere around 240fps if I let it run free. Which I mean, is pretty respectable. Why doesn't it run well on the deck? Technically, it's running okay, just not displaying okay. The internal game logic does all physics and animation calculations with lag compensation in mind. So whether you're getting 500 fps or 5, the in-game logic always calculates 60Hz. So sorry - no cheesing stage times with slow-mo. One reason the display is having issues is that it's single threaded. Which means we're not doing _anything_ in parallel. All of the game logic, graphics rendering, controller polling, etc. are all being done every frame in order every single time. The kicker is that we actually built the game to be able to do those things in parallel, but Javascript just doesn't have the concept of Threads for you to be able to just run whatever you want however you want. You have to implement Web Workers, which is essentially a completely separate program that you can't share memory with, forcing you to use a message bus, making life difficult. But not impossible, and that's all that really matters. Just splitting it in 2 would already get us a 25% improvement, and we could very likely do better than that. The other, slightly more major performance sink is that green bar for the Phaser rendering - that can be entirely eliminated at this point to cut the time in half. We've been replacing it piece-by-piece with our own code, and now, we're really just leaning on it for WebGL pushes at this point. Unfortunately, since it's an engine, there's quite a bit of extra baggage that it likes to do that we can't just turn off, so we're essentially running a lot of the same types of graphics calculations twice. Phaser is a perfectly good engine - don't get me wrong, but it's just superfluous for our use at this point, specifically for us.

So yeah - it's going to take another week or so to get that 100% sorted out. There's a patch incoming Monday for full Controller support and couple of minor improvements. In the meantime, you can swap to the beta branch on Steam if you absolutely must try the Steam Deck version now. No complaints about the speed though - I warned you.

[occasionaltouhou]

what kind of OS does the typical shikigami run on? personally ran gives me big linux vibes, possibly arch.

i know nothing about computers or programming. shikigami operate by suppressing a core soul's nature via a large number of nameless spirits (yukari uses vengeful spirits, but any kind will do) with specific instructions, information, instincts, etc. which are forcibly conglomerated together to create a new entity, which is the shikigami.

any attempt to directly rather than merely metaphorically compare the construction of shikigami to the human programming of machines that do not think for themselves is ultimately futile. although they are both highly complicated tools used to perform calculations and tasks faster than a human would be able to - or at the very least tasks they are unwilling to spend the time on - their fundamental natures are completely different.

i wrote this, with my words, in the thing that i wrote.

[c-53]

WARNING: LONG ASK INCOMING

For hobby electronics there’s two major kinds of processors: Microcomputers and Microcontrollers. Microcomputers are small full computer systems like the Raspberry Pi, they typically run a general-purpose OS (typically some flavor of Linux) and are useful for the kinds of projects that require basically a full computer to function, but not necessarily individual sensors. They’re a great place to start for people who don’t know a whole ton about programming or working with individual components because they typically can output a true GUI to a screen and have the capabilities of a regular desktop computer. They have a main processor, true RAM, and either large on-board storage space or a way to read a storage device, like an SD card.

Microcontrollers are less complicated (component wise) than microcomputers, but as a result are more difficult for total beginners to begin working with. They’re typically primarily a SoC (System on a Chip) processor without discrete RAM modules and a very small EEPROM (on-ship storage space) and need to have components wired and configured to them to be able to do much more than being a fancy calculator. They’re used for when you need something to carry out electronic functions or get sensor readings, but not necessarily a full operating system, so they’re best suited for small/integrated applications. Your helmet uses a microcontroller to control the LEDs you used in the Cunt Machine post.

I build high-power model rockets as a hobby and with my university team, so I work with both kinds of processor as part of designing payload systems. I typically prefer microcontrollers in these as most of what we do doesn’t need an actual OS to run, and they’re smaller/lighter than microcomputers. One of the advantages of a microcontroller is that it runs a Real-Time OS (RTOS) which forgoes all the user-friendliness of things like windows and linux to instead be the bare minimum backend necessary to run code uploaded into the processor. 

The main advantage of using a microcontroller is really that they’re typically a lot cheaper than microcomputers are and are plenty powerful for really embedded applications. They also make other parts of whatever system is being built cheaper/easier to integrate because they require less overhead to function - the raspberry pi needs a minimum of 5 volts of power to work, while a chip like an ESP32-PICO can run at 1.8V. 

The main way you make sensors/buttons/peripherals work with a microcontroller is via digital communication busses. There’s a few protocols, the most common being I2C, SPI, and UART. I’ll talk about I2C since that’s generally the most common. With I2C each component is assigned a 2-byte “address” that they’re identified by. When the controller sends a request signal on the I2C data bus, every sensor along the line will return their own signal, marked with their address so that they can be identified. It allows for a large number of devices to be put on the same lines and you can daisy-chain them through each other to the microcontroller.

I’ll be honest I really can’t think of a good way to say much more on the subject as like a starting message because I’ve been working with computers so long all the tech stuff for me is second nature, but if you have any questions ask away I can probably answer them or google them.

.

[digitalmarketpk-blog]

Honeygain App Download | Earn Passive Income in 2024

In today's digital age, finding ways to make passive income online has become increasingly popular. One app that stands out in this realm is Honeygain. This app allows users to earn money effortlessly by sharing their internet bandwidth. By simply running the Honeygain app on your devices, you can start earning passive income without any upfront investment.

What is Honeygain?

Honeygain is a unique app that enables users to earn money by sharing their unused internet bandwidth. The app is designed to be easy to use and is available for download on multiple platforms, including Windows, Android, iOS, and Linux.

Getting Started with Honeygain Download

Download and Installation

Downloading and installing the Honeygain app is straightforward. You can download the honeygain app on your preferred platform:

Windows

macOS

Linux

iOS

Android

You can also download the Honeygain APK file for Android devices. After downloading the app, you need to register using your email address and confirm your registration. Once installed and active, Honeygain securely shares your internet connection without accessing your personal data. The app can be run on multiple devices to maximize your earning potential.

Welcome Bonus

If you are new to Honeygain, there is a special welcome bonus for you. By joining Honeygain, you receive a $5 gift to kickstart your journey of earning passive income.

How Does Honeygain Work?

Once you have set up the Honeygain app on your device, it starts sharing your internet connection to gather publicly available data online. This data is used by credible companies for purposes such as web statistics, price comparison, and other business processes. Your earnings begin within ten minutes of joining, and you earn money for all the traffic you share.

You can choose to receive your payouts via PayPal or in cryptocurrency. To maximize your profit, it's advisable to use multiple devices and share as much internet bandwidth as possible.

Honeygain Review and Trustscore

Before using any app, it's essential to understand its credibility and trustworthiness. Honeygain has received excellent reviews on Trustpilot, with a trust score of 4.5 stars based on over 11,000 reviews. This high rating indicates a strong level of trust and satisfaction among its users.

Refer a Friend and Earn Extra Income

Honeygain offers a referral program that allows you to earn additional income by inviting your friends to join. Each new user who joins through your referral link receives a $5 bonus. Additionally, you earn a 10% bonus based on the traffic shared by your referrals. When your referral shares at least 2GB of data, you receive an extra 500 Honeygain credits.

Honeygain Calculator: Estimate Your Earnings

Honeygain provides a calculator to help you estimate your potential earnings. For instance, by sharing 20GB of traffic per month using ten different IP addresses, you could earn approximately $180. This estimate helps you understand the earning potential and how much you can make by sharing your internet bandwidth.

Honeygain and JumpTask Collaboration

Honeygain has partnered with JumpTask, a renowned earning platform, to offer users an opportunity to earn even more. By connecting your Honeygain account with JumpTask, you can earn an additional 10% bonus on all your earnings.

Conclusion

Honeygain is a reliable and easy-to-use app that allows you to earn passive income by sharing your internet bandwidth. With its high trust score, welcome bonus, and referral program, it offers a straightforward way to make extra money. Additionally, the collaboration with JumpTask provides an opportunity to boost your earnings even further. You can refer to detailed information on coinbaba.net. Whether you're using a Windows, macOS, Linux, iOS, or Android device, Honeygain makes it simple to start earning today.