furtidev

Please, let my laptop sleep

Unknown — Sun, 31 Aug 2025 00:00:00 +0000

suspend/sleep</code> on Linux has been a hit or miss for me. Sometimes it'd work fine, other times it won't. By "won't" I mean a very specific sequence:</p>


Power is cut off from the keyboard, mouse and screen</li>
I can tell my laptop is still on, since the indicator light is still lit</li>
Either I wait for the battery to drain or I hard-poweroff the laptop</li>
</ul>
Guess what I used to do? I'm surprised no components are damaged yet. But perhaps that's because components that could be damaged were already not receiving power. It's messy. But why is it happening? Had no clue for a long time. I sought answers from many, yet found none. But I recall one of them told me some systems have trouble with this. This was actually a good hint, but although useless to then-me. The ArchWiki entry on power management also had a good hint:</p>

Suspend to RAM (aka suspend)</strong> 

The S3 sleeping state as defined by ACPI</mark>, ...</p>
</blockquote>
So it's some sort of discrepancy between the ACPI tables in my firmware and the Linux kernel. If only I had investigated that earlier, I could have spared myself from a ton of pain.</p>
On some laptops, the DSDT</a> table is tuned specifically for Windows in mind, and so it's difficult for the Linux kernel to interface with it properly. Most functionalities seemed</em> to work, but sleep and shutdown consistently gave me trouble.</p>
Apparently you can re-build the firmware DSDT table, but doesn't seem fool-proof and rather unnecessary in my case. Instead, I ended up adding a few kernel parameters to my GRUB config to camouflage the Linux kernel as Windows when interfacing with ACPI:</p>

/etc/default/grub</p>
</blockquote>
1</span># GRUB boot loader configuration</span></span>
2</span></span>
3</span>GRUB_DEFAULT</span>=</span>'0'</span></span>
4</span>GRUB_TIMEOUT</span>=</span>'5'</span></span>
5</span>GRUB_DISTRIBUTOR</span>=</span>'EndeavourOS'</span></span>
6</span>GRUB_CMDLINE_LINUX_DEFAULT</span>=</span>'nowatchdog nvme_load=YES loglevel=3 acpi_osi=! acpi_osi="Windows 2020"'</span> # only use Windows 2020 as the interface</span></span>
7</span>GRUB_CMDLINE_LINUX</span>=</span>""</span></span>
8</span>...</span></span></code></pre>
The kernel parameters and their possible values are all documented in the DSDT article I linked above. Ironically, I found this solution using ChatGPT. It's a bit sad. It's all well documented on ArchWiki, and I opted for slop instead. I was actually surprised.</p>
Wow, AI fixed a problem nobody else could?1?! It's joever.</em></p>
But turns out it's a very common problem, just that the people I asked also never read the ArchWiki article on power management. But ChatGPT? Oh, it scraped the entire internet alright. So what's the takeaway from all this? It's to always READ THE FUCKING MANUAL.</p>
Apparently there are plenty of other reasons why power management could go wrong on Linux, some of them are more complicated than others. I found a good article on ACPI and Linux: How I discovered that Bill Gates monopolized ACPI in order to break Linux</a>. You SHOULD read it. NOW. I'm glad mine was very simple to fix. Finally, I can put my laptop to sleep as I sing it a sweet lullaby on Rust and the borrow checker.</p>



Setting up Wine + Bottles on an external drive
Unknown — Sun, 25 May 2025 00:00:00 +0000
ToC</h2>

Step 1: Setup Flatpak</a></li>
Step 2: Setup Bottles</a></li>
Step 3: Running games</a></li>
</ul>
So here's the deal:</p>

I'm dual booting with Windows 10.</li>
My Linux partition doesn't have as much storage, because at the time, I thought I wouldn't want to play games while on the Linux boot and nothing else takes much space. Movies? Manga? Anime? I can store them on one of the Windows partitions easily (thanks to whoever wrote NTFS drivers for Linux).</li>
I don't want to boot into Windows 10 everytime I want to play a game.</li>
</ul>
It's simple enough to run native Linux games while storing them on an NTFS partition. But, what if I want to play games that don't have Linux builds (or have broken Linux builds)? I'll need Wine. I'm familiar with Bottles</a>, a very easy to use Wine prefix manager.</p>
It's a bit involved to set up Bottles in this scenario to use Windows partitions (could be external drives, but I only have one drive split into partitions, takes the same process) for storage instead of filling up my already tiny Linux one. But it isn't that hard and I want to document it.</p>
Step 1: Setup Flatpak</h3>
You need Flatpak if you want to use Bottles since it's mainly distributed through Flathub. I know, it's a bit annoying and flatpaks are space hungry (because of which this whole blog exists) but it is what it is.</p>
Install Flatpak</a> through your distro's intended way, and setup Flathub on it. Don't install anything with it yet.</p>
We want to change some configuration. Mount your desired drive where you want to store all this. For me, it's a Windows partition mounted at /run/media/furtidev/Games</code>. This drive always needs to be mounted before you run Bottles after we're done.</p>
First things first, create the configuration directory if it doesn't exist already:</p>
# -p doesn't error out if a directory already exist.</span></span>
$</span> sudo mkdir -p /etc/flatpak/installations.d</span></span></code></pre>
Next up, let's edit a file there:</p>
$</span> sudoedit /etc/flatpak/installations.d/gaming.conf</span> # could be named anything</span></span></code></pre>
Append this:</p>

/etc/flatpak/installations.d/gaming.conf</p>
</blockquote>
[Installation "gaming"]</span></span>
Path=/run/media/path/to/your/drive/flatpak # for me: /run/media/furtidev/Games/Linux/Flatpak</span></span>
DisplayName=Flatpak installation for gaming needs</span></span>
StorageType=harddisk # mmc, sdcard, harddisk, network</span></span></code></pre>
You need to ensure that Path</code> already exists. Save and you're done.</p>
Step 2: Setup Bottles</h3>
$</span> flatpak --installation=gaming install flathub com.usebottles.bottles</span></span></code></pre>
This will take a while depending on your internet speed.</p>
Here's the thing: while Bottles itself is installed on the other drive/partition that you specified in /etc/flatpak/installations.d/gaming.conf</code>, it's data is still residing on your current Linux partition. We don't want that. But first, run Bottles for the first time.</p>
$</span> flatpak --installation=gaming run com.usebottles.bottles</span></span></code></pre>
The --installation</code> flag is optional if this is the only Bottles you have. Let it do it's thing and exit once you're on the main screen.</p>
We're going to use symlinks to trick Bottles into storing data elsewhere.</p>
Bottles stores it's files at ~/.var/app/com.usebottles.bottles</code> (you can check right now if there's anything there). We're interested in the ~/.var/app/com.usebottles.bottles/data</code> folder.</p>
$</span> mv ~/.var/app/com.usebottles.bottles/data /run/media/path/to/your/drive/flatpak/bottles_data</span></span></code></pre>
Of course, the exact path depends on you, it doesn't have to be flatpak/bottles_data</code>. Let's give Bottles permissions to access our new location.</p>
$</span> sudo flatpak override --installation=gaming --filesystem=/run/media/path/to/your/drive/flatpak/bottles_data com.usebottles.bottles</span></span></code></pre>
You might not need sudo</code>. Anyway, now's the imporant part: we need to symlink /run/media/path/to/your/drive/flatpak/bottles_data</code> to ~/.var/app/com.usebottles.bottles/data</code>.</p>
$</span> ln -s /run/media/path/to/your/drive/flatpak/bottles_data ~/.var/app/com.usebottles.bottles/data</span></span></code></pre>
And you're done. Run Bottles to see if everything's working fine.</p>
Step 3: Running games</h3>
I've noticed that I can't access my game files if I don't give Bottles permission to read those directories. So I'm going to show a few examples of how you might go about this:</p>
$</span> sudo flatpak override --installation=gaming</span> \</span></span>
	 --filesystem=/run/media/path/to/your/drive/Games com.usebottles.bottles</span></span>
</span>
# OR</span></span>
</span>
$</span> sudo flatpak override --installation=gaming</span> \</span></span>
	 --filesystem=/run/media/path/to/your/drive/Games/TES4Oblivion com.usebottles.bottles</span></span></code></pre>
I haven't tried setting up Steam because I don't own anything that doesn't have a native Linux build.</p>
It was worth it</h3>
In the end, my Flatpak installation ended up being 6.4G and Bottles data ended up being 3.2G big. And that's without any games. I couldn't "waste" this much storage on my Linux partition. This was worth it.</p>


What's so hard about writing a JSON parser?
Unknown — Sun, 19 Jan 2025 00:00:00 +0000
I always assumed JSON was a complex format to implement, but it's quite simple. So simple that you don't even need to read RFC 8259 - there's a simple, straight to the point webpage denoting JSON in it's entirety in just a few lines and some pretty pictures (yay!). If you've never done this before, and want to write a parser for JSON yourself then go to the JSON spec</a> website and have fun. You'll need to learn about some basic concepts as well, such as tokenization, parsing and abstract syntax trees.</p>
I'll do a overview: Tokenization or lexing, is the process of giving meaning to characters (e.g in Python, the characters f</code>, o</code> & r</code> don't mean anything on their own, but together they form the for</code> keyword, this is the job of the lexer). After you're done lexing, you're left with a bunch of tokens for keywords, number and string literals etc. The tokens themselves can contain additional data, such as the line & column in the original source code from where they came from. More importantly, some tokens do need to hold on to the original value. For example, a NUMBER</code> token should contain the integer value the token was generated from, otherwise that data will be lost. These still don't mean anything. Parsing is the process of giving meaning to a stream of tokens by using a data structure to represent the original structure and thus meaning, of the source code. Trees are commonly used to represent source code because they naturally map to the hierarchy of code, referred to as the abstract syntax tree (AST) or parse tree. You may find Wikipedia's entry on ASTs helpful but of course, there are plenty of content on the internet about this.</p>
Now, if you don't want any more hints, then you should stop reading this blog right here and come back later when you're done with your parser and if you want, compare with my approach.</p>
Keep in mind that I'll use ...</code> to indicate lines of code not shown in the snippets. Also this isn't a tutorial on how to write a JSON parser as I'll only be talking about what kind of decisions I made on certain aspects. I was learning some Rust a while ago and wanted to test what I had learned so far, so I decided to write my parser in Rust. Tokenization was fairly easy but there are some catches. Numbers in JSON map to JavaScript numbers, so one key feature is scientific notation: 10e-5</code> evaluates to 0.0001</code>. Rust also supports this, so parsing numbers was really just as simple as capturing the string and casting it to a float.</p>

tokenizer.rs</p>
</blockquote>
1</span>let</span> num_result</span>:</span> Result</span><</span>f64</span>,</span> _</span>></span> = iter</span>::</span>once</span>(</span>ch</span>)</span></span>
2</span>    .</span>chain</span>(</span>from_fn</span>(</span>||</span> {</span></span>
3</span>        self</span>.</span>input</span>.</span>by_ref</span>()</span>.</span>next_if</span>(</span>|</span>s</span>|</span> {</span></span>
4</span>            s</span>.</span>is_ascii_digit</span>()</span></span>
5</span>                || *</span>s</span> ==</span> '</span>e</span>'</span></span>
6</span>                || *</span>s</span> ==</span> '</span>E</span>'</span></span>
7</span>                || *</span>s</span> ==</span> '</span>-</span>'</span></span>
8</span>                || *</span>s</span> ==</span> '</span>+</span>'</span></span>
9</span>                || *</span>s</span> ==</span> '</span>.</span>'</span></span>
10</span>        })</span></span>
11</span>    }))</span></span>
12</span>    .</span>collect</span>::<</span>String</span>>()</span></span>
13</span>    .</span>parse</span>();</span></span></code></pre>
String literals took a bit more effort, my tokenizer was getting confused between string literals and true</code>/false</code>/null</code> values. In JSON, string literals can only begin with double quotes, so I came up with a simple trick, the tokenizer switches to "string parsing mode" when it detects a double quote.</p>

tokenizer.rs</p>
</blockquote>
1</span>match</span> ch</span> {</span></span>
2</span>    ...</span></span>
3</span>    '</span>"</span>'</span> =></span> {</span></span>
4</span>        self</span>.</span>string_mode </span>= !</span>self</span>.</span>string_mode</span>;</span></span>
5</span>        tokens</span>.</span>push</span>(</span>Token</span>::</span>Quote</span>);</span></span>
6</span>    }</span></span>
7</span>    ...</span></span>
8</span>}</span></span></code></pre>
So, now in the next iteration, the tokenizer checks if string_mode</code> is true</code> and checks to make sure the current token is not a double quote (because that would mean the string literal has ended). I wrote a helper function called make_string()</code> to deal with the parsing. Now, this function is poorly designed or perhaps you could say, it's poorly named. Because it also handles the logic for creating true</code>/false</code>/null</code> tokens. You might wonder why, but it's simply because the logic for parsing string literals and these special tokens were quite similar, and I .. got a bit lazy so I merged them into a single function.</p>

tokenizer.rs</p>
</blockquote>
1</span>if</span> self</span>.</span>string_mode </span>&&</span> ch</span> !=</span> '</span>"</span>' {</span></span>
2</span>    let</span> tok</span> =</span> Token</span>::</span>Str</span>(</span>self</span>.</span>make_string</span>(</span>false</span>));</span> // false means it's not a special token but a literal</span></span>
3</span>    tokens</span>.</span>push</span>(</span>tok</span>);</span></span>
4</span>    self</span>.</span>advance</span>();</span></span>
5</span>    continue</span>;</span></span>
6</span>}</span></span>
7</span>...</span></span>
8</span>match</span> ch</span> {</span></span>
9</span>    ...</span></span>
10</span>    '</span>t</span>'</span> |</span> '</span>f</span>'</span> =></span> {</span></span>
11</span>        let</span> bool_value</span> =</span> self</span>.</span>make_string</span>(</span>true</span>);</span></span>
12</span>        if</span> bool_value</span> ==</span> "true"</span> {</span></span>
13</span>            tokens</span>.</span>push</span>(</span>Token</span>::</span>Bool</span>(</span>true</span>))</span></span>
14</span>        }</span> else if</span> bool_value</span> ==</span> "false"</span> {</span></span>
15</span>            tokens</span>.</span>push</span>(</span>Token</span>::</span>Bool</span>(</span>false</span>))</span></span>
16</span>        }</span></span>
17</span>    }</span></span>
18</span>}</span></span></code></pre>
String literals can also use escape sequences (only a handful are supported by the spec) but fortunately implementing them is trivial. Similar to how if the tokenizer detects a double quote it goes into string parsing mode, this time, if the string parser detects a forward slash (\</code>) - it goes into escape mode.</p>

tokenizer.rs</p>
</blockquote>
1</span>let mut</span> ident</span> =</span> String</span>::</span>new</span>();</span></span>
2</span>let mut</span> escape_mode</span> =</span> false</span>;</span></span>
3</span></span>
4</span>while let</span> Some</span>(</span>ch</span>)</span> =</span> self</span>.</span>input</span>.</span>peek</span>() {</span></span>
5</span>    ...</span></span>
6</span>    if</span> *</span>ch</span> !=</span> '</span>"</span>'</span> && !</span>escape_mode</span> {</span></span>
7</span>        // go to escape mode if `\` was detected.</span></span>
8</span>        if</span> *</span>ch</span> ==</span> '</span>\\</span>' {</span></span>
9</span>            escape_mode</span> =</span> true</span>;</span></span>
10</span>            self</span>.</span>advance</span>();</span></span>
11</span>            continue</span>;</span></span>
12</span>        }</span></span>
13</span>        ident</span>.</span>push</span>(</span>*</span>ch</span>);</span></span>
14</span>        self</span>.</span>advance</span>();</span></span>
15</span>    }</span> else if</span> escape_mode</span> {</span></span>
16</span>        // parse JSON standard escape codes</span></span>
17</span>        match</span> *</span>ch</span> {</span></span>
18</span>            '</span>"</span>'</span> =></span> ident</span>.</span>push</span>(</span>*</span>ch</span>),</span></span>
19</span>            '</span>\\</span>'</span> =></span> ident</span>.</span>push</span>('</span>\\</span>'),</span></span>
20</span>            '</span>/</span>'</span> =></span> ident</span>.</span>push</span>('</span>/</span>'),</span></span>
21</span>            '</span>b</span>'</span> =></span> ident</span>.</span>push</span>('</span>\u{0008}</span>'),</span></span>
22</span>            '</span>f</span>'</span> =></span> ident</span>.</span>push</span>('</span>\u{000c}</span>'),</span></span>
23</span>            '</span>n</span>'</span> =></span> ident</span>.</span>push</span>('</span>\u{000a}</span>'),</span></span>
24</span>            '</span>r</span>'</span> =></span> ident</span>.</span>push</span>('</span>\u{000d}</span>'),</span></span>
25</span>            '</span>t</span>'</span> =></span> ident</span>.</span>push</span>('</span>\u{0009}</span>'),</span></span>
26</span>            _</span> =></span> {}</span></span>
27</span>        }</span></span>
28</span>        escape_mode</span> =</span> false</span>;</span></span>
29</span>        self</span>.</span>advance</span>();</span></span>
30</span>    }</span> else</span> {</span></span>
31</span>        // non-escape quote detected, end string.</span></span>
32</span>        break</span>;</span></span>
33</span>    }</span></span>
34</span>    ...</span></span>
35</span>}</span></span></code></pre>
So with that, the tokenizer is done. If you're wondering, here are all the token variants:</p>

tokenizer.rs</p>
</blockquote>
1</span>pub enum</span> Token</span> {</span></span>
2</span>    LeftBrace</span>,</span></span>
3</span>    RightBrace</span>,</span></span>
4</span>    LeftBracket</span>,</span></span>
5</span>    RightBracket</span>,</span></span>
6</span>    Quote</span>,</span></span>
7</span>    Comma</span>,</span></span>
8</span>    Colon</span>,</span></span>
9</span>    Str</span>(</span>String</span>),</span></span>
10</span>    Number</span>(</span>f64</span>),</span></span>
11</span>    Bool</span>(</span>bool</span>),</span></span>
12</span>    Null</span>,</span></span>
13</span>    Eof</span>,</span></span>
14</span>}</span></span></code></pre>
Writing the lexer took me 3 hours, spread across two days. The parser was actually a bit simpler. The hard part was figuring out a coherent structure to represent JSON. Rust is a strictly typed language, I can't plop a f64</code> into a bool</code>, the compiler will refuse to compile. But the issue is, JSON doesn't have such restrictions, you can put a boolean, a string or a number as values anywhere (except keys, they can only be string literals). Also, JSON files can be as simple as this:</p>

a_perfectly_valid_json_file.json</p>
</blockquote>
true</span></span></code></pre>
Which means the root of a JSON file can be anything, but commonly it's an array or a key-value structure (called objects</em> in the spec). Now the question is: how do we represent this dynamic file format in Rust? You see, enums in Rust can hold values and this feature can be used to achieve the dynamism we need. We just need to define an enum with all possible types of values and just refer to the enum type everywhere else - a job well done. To be fair, this isn't anything revolutionary. I didn't come up with this, it's a common practice in Rust.</p>

parser.rs</p>
</blockquote>
1</span>pub enum</span> Value</span> {</span></span>
2</span>    Null</span>,</span></span>
3</span>    Str</span>(</span>String</span>),</span></span>
4</span>    Num</span>(</span>f64</span>),</span></span>
5</span>    Bool</span>(</span>bool</span>),</span></span>
6</span>    Obj</span>(</span>Object</span>),</span></span>
7</span>    Arr</span>(</span>Array</span>),</span></span>
8</span>}</span></span></code></pre>
I could've mapped JSON objects to a std::collections::HashMap</code> but in the end I went with my own structs for both objects and arrays, their definitions are simple.</p>

parser.rs</p>
</blockquote>
1</span>pub struct</span> Root</span> {</span></span>
2</span>    pub</span> child</span>:</span> Option</span><</span>Value</span>>,</span></span>
3</span>}</span></span>
4</span></span>
5</span>// {... properties ...}</span></span>
6</span>pub struct</span> Object</span> {</span></span>
7</span>    pub</span> children</span>:</span> Vec</span><</span>Property</span>>,</span></span>
8</span>}</span></span>
9</span></span>
10</span>// [... any values ...]</span></span>
11</span>pub struct</span> Array</span> {</span></span>
12</span>    pub</span> children</span>:</span> Vec</span><</span>Value</span>>,</span></span>
13</span>}</span></span>
14</span></span>
15</span>// "key": value</span></span>
16</span>pub struct</span> Property</span> {</span></span>
17</span>    pub</span> lhs</span>:</span> String</span>,</span></span>
18</span>    pub</span> rhs</span>:</span> Value</span>,</span></span>
19</span>}</span></span></code></pre>
As you can see, wherever JSON allows any valid value, we put our newly created enum Value</code> as the type. The parser starts by creating a root node and iterating through the tokens. Parsing needs to be recursive when you have things that can contain themselves (e.g an array can contain more arrays), so keeping this in mind, we determine the root value, and if it's an array or an object, we call their respective parsing functions, this easily helps to make the entire process recursive because within those functions we call the parsing functions again if we detect arrays or objects, and so on and so forth. Now, I got a bit lazy again and did a lot of code duplication for each of these functions, and there are nicer ways to do it but I had already crossed the deadline I set for myself so some corners were cut.</p>

parser.rs</p>
</blockquote>
1</span>fn</span> parse</span>(</span>&</span>mut</span> self</span>)</span> -></span> Root</span> {</span></span>
2</span>    let mut</span> root</span>:</span> Root</span> =</span> Root</span> {</span> child</span>:</span> None</span> };</span></span>
3</span></span>
4</span>    while let</span> Some</span>(</span>tok</span>)</span> =</span> self</span>.</span>curr_tok</span>.</span>clone</span>() {</span></span>
5</span>        match</span> tok</span> {</span></span>
6</span>            ...</span></span>
7</span>            Token</span>::</span>LeftBracket</span> =></span> {</span></span>
8</span>                let</span> array</span> =</span> self</span>.</span>parse_array</span>();</span></span>
9</span>                root</span>.</span>child </span>=</span> Some</span>(</span>Value</span>::</span>Arr</span>(</span>array</span>));</span></span>
10</span>            }</span></span>
11</span>            Token</span>::</span>LeftBrace</span> =></span> {</span></span>
12</span>                let</span> object</span> =</span> self</span>.</span>parse_object</span>();</span></span>
13</span>                root</span>.</span>child </span>=</span> Some</span>(</span>Value</span>::</span>Obj</span>(</span>object</span>));</span></span>
14</span>            }</span></span>
15</span>            ...</span></span>
16</span>        }</span></span>
17</span>        ...</span></span>
18</span>    }</span></span>
19</span></span>
20</span>    root</span></span>
21</span>}</span></span></code></pre>
So those were all the necessary puzzles that needed to be solved, and soon enough I had a functioning parser. I haven't benchmarked it but it's definitely not faster than production grade parsers written in Rust. This is a rather naive implementation. So I've accurately named it: furtidev/dumb_json_parser</a>. Take a look at the GitHub repo if you are interested in all the code. I wrote an example app where I was directly using the "tree" and I noticed a lot of repetition. Perhaps it can be quite nice to use if I add some high-level APIs. Perhaps another time. Recreational projects like these are fun to work on and I have a few lined up, hopefully when they're done I can write about them too. Goodnight.</p>
 
 @TheGingerBill: If you cannot write a parser for JSON from scratch: you need to learn how to do that NOW!</span></center>


Trying Ghostty: My experience with terminal emulators
Unknown — Sun, 10 Nov 2024 00:00:00 +0000
Childhood</h1>
I first started programming on an Android phone, basically running a PHP 7.x and MySQL 5.x server (I couldn't find the app I was using for that at the time) and using a barebones text editor (it was probably this one</a>). I didn't need to interact with terminals. That all changed in 2021, when I was using the terminal more frequently. As far as terminal emulation goes, I just used the basic Command Line, yeah, the Windows one - yikes. I can't imagine how I programmed on Windows.</p>
Adolescence</h1>
But after some time, I found Alacritty</a>. It was fast, it made me feel cool. I installed all the hip stuff, like Starship</a> prompt. But Alacritty had no support for tabs and I love</em> organizing things via tabs. So it was inconvenient and on top of that, after going through this discourse</a> on their GitHub, I guess it's safe to say that Alacritty will never have tabs. From this thread and some googling, I learned about Kovid Goyal's kitty terminal emulator</a> - but I was disappointed because kitty</code> wasn't on Windows. Okay, I guess I'll use a terminal multiplexer.. oh no I can't - neither zellij</a> nor tmux are natively supported on Windows. I think I did try Wezterm</a> somewhere along the way, but it didn't stick for long.</p>
Redemption</h1>
On 13th of January, 2023 (yes, I noted down the exact date), I switched to Linux. That means I could finally use kitty</code>. But I had a thought.. what if I just use Alacritty with zellij</code>? I did that for a bit and couldn't get used to using a terminal multiplexer for tabs, so - kitty</code> it is. So all in all, I've used kitty</code> for quite some time up until a ghost</strong> started haunting me. Before moving on to talking about that, kitty</code> deserves some words. I like it a lot - with the occassional SSH ragequit</a>, you could say it was a love-hate relationship, majority of it being love though. But anyway, I'm supposed to talk about .. the hauntings of a ghost.</p>
Enter Ghostty</h1>
Mitchell Hashimoto</a>. You might know him. He's just this niche guy, co-founder of HashiCorp</a></strong></em>. So, when he announced that he was working on a terminal emulator written fully in Zig - there was hype. This was the light in the darkness, as Warp (no, I don't feel like linking Warp) receives $73M in funding for their terminal emulator where you have to log in, yes, log in to use your terminal, the coming of Ghostty showed light to the believers.</p>
Ghostty is still in private beta, with a 1.0 release</a> coming in December, 2024. Mark your calendars, folks. I got invited into the private beta right before Halloween, so it fits.</p>
Purpose</h3>
But why does Ghostty exist? There are a few key reasons:</p>


Native UI</strong>. It uses GTK on Linux and SwiftUI on MacOS. This also means native tabs support. While kitty</code> does support tabs, it doesn't use native widgets.</p>
</li>

Extremely fast</strong>, often beating Alacritty.</p>
</li>

Feature-rich</strong>. Supports kitty image protocol, native support for emojis, built-in terminal inspector for rich terminal debugging etc.</p>
</li>

Most importantly</strong>, all of this in a complete</em> cross-platform package. Before Ghostty, there wasn't a single terminal emulator that had all of the aforementioned perks. See figure 1 & 2 below for a summary.</p>
</li>
</ul>
 
 Figure 1: Chart comparing popular terminal emulators with Ghostty</span></center>
 
 Figure 2: Core purpose of Ghostty.</span></center>
 
 Native tabs, using GTK on Linux</span></center>
 
 Image rendering using Kitty Image Protocol (image: NCR Veteran Ranger Helmet)</span></center>
 
 Built-in terminal inspector for TUI debugging</span></center>
What more could one ask for?! Well, as it turns out.. a lot more. Ghostty wants to be the browser-equivalent for TUIs (terminal user interface). It wants to have native support for progress bars, context menus, drag & drop, mouse gestures and so much more - a complete platform for text based user interfaces. I mean, that's A LOT to take in, even though these are long-term goals. It's ambitious, it's exciting, and finally there's someone willing to bring innovations to the terminal.</p>
At the core of Ghostty, there's libghostty</code>, a cross-platform library that powers Ghostty. I like where they're going with this, essentially you can use libghostty to ship whatever you want: standalone TUI applications, embedding Ghostty in other places and even getting a terminal emulator running on the web, seems like your imagination is the limit. Ghostty itself is a software using libghostty. Sort of like how the Godot game engine is a Godot "game". libghostty</code> will eventually be available as a standlone library, and I'm excited for that - it exposes a C api so you can use whatever language you want with it as long as it can interface with C.</p>
Even though it currently only supports MacOS and Linux, Windows support is planned for sometime after the 1.0 release. I'll shed a tear when that happens, considering the pain I had to go through to find an appropriate terminal emulator for my needs on Windows.</p>
So even though I was a bit confused by why Ghostty needs to exist at first, I'm now completely sold. And to be completely honest, you</em> should be too.</p>
Daily driving</h3>
Ever since I got access to the private beta, Ghostty has been my daily driver. Sorry cat terminal. Apart from some weird issues here and there which I reported, it has been fantastic. The community is friendly, there's an active group of developers writing TUIs on Ghostty and some are contributing to the project itself. Point is, Ghostty gets out of the way and lets me do my work peacefully. I also giggle once in a while thinking a ghost is watching me while I run my commands. So if you were wondering if it's ready for some rigorous daily use, now you know.</p>
I'm not an avid recompiler, in fact I haven't recompiled Ghostty ever since. I should really do it one of these days.</p>
Conclusion</h1>
Need I say more? I'm sure I've gotten my point across, yes, Ghostty is good. You should use it when it's out. Also, why not join the Discord</a>? I forgot to mention a killer</em> feature: shaders. I wrote a small TUI to make the best use of it (if you can't tell, I've been playing a lot of Fallout: New Vegas):</p>
 
 I got spurs that jingle, jangle, jingle</span></center>
There's also a repository for Ghostty shaders: hackrmomo/ghostty-shaders</a>. And lastly:</p>

Childhood: Clueless early days of programming.</li>
Adolescence: Still clueless, but pretending to be wise using Windows for development.</li>
Redemption: Making up for my past crimes and switching to Linux.</li>
</ul>
Also, I can't wait to actually contribute to Ghostty someday, but that's for another time. For now, I gotta take a nap. This blog took [calculates time]</em> at least 3 hours. Goodbye, Good Night, Oyasumi and everything else.</p>


My experience with password managers
Unknown — Mon, 11 Sep 2023 00:00:00 +0000
Back when I was a foolish young man, I used the same password everywhere so that I won't have to struggle with remembering what password I set for what account. In retrospect, that was a very, very stupid decision. And as you can guess, I got pwned</a>!</p>
So after that I finally decided to use a password manager. So I'll be sharing my experience with the ones I've used so far.</p>
LastPass (don't)</h2>
I chose LastPass at first because Daddy Google had it on top of the search results when I looked up 'Best Password Manager'. I was using it until LastPass had a data breach last year, it was a huge mess. A few months later the company revealed that GoTo's (the company behind LastPass) other services were also attacked, plus encrypted backups with encryption keys for said backups</strong> and MFA data were also stolen.</p>
GoTo didn't give any more details about it, like how old the backups were etc. LastPass is a horrible service. GoTo is a horrible company, the handled the breach very poorly. Constantly getting spammed with promotional e-mails was also very annoying. I just exported all my data, changed all my passwords and switched to BitWarden.</p>
BitWarden (great)</h2>
I just said to myself, "Heh, it can't be worse than LastPass", and went in. First of all, BitWarden is open source on GitHub</a>. I used the free plan but the personal premium plan is also great, only $10/year. Unlike LastPass, BitWarden actually encrypts all your fields. I had a very strong and long (that's... what... she.... said....) master password.</p>
Regular security audits conducted by notable third-party security firms, open source, self-hostable, generous free plan, transparent company, zero knowledge encryption</a> (white paper</a>), good reputation and I like their philosophy towards security.</p>
BitWarden one day randomly locked me out of my account with the following error: "Traffic from your network looks unusual" - why? I don't know! But either way, it was enough of a reason to not use BitWarden anymore.</p>
KeePassXC (currently using, great)</h2>
I currently use KeePassXC. There's no server involved, you just download KeePassXC and start using it. Importing data from BitWarden wasn't hard though it wasn't seamless either. I just save regular backups of my database on the cloud, and use a strong master password. Plus, you can also use YubiKey and OnlyKey for extra protection. It is also open source software and I like that everything about it is handled by me and me only. I also use it for OTP.</p>
I'm no encryption/security specialist, I just wanted to share my experience so if I've made any mistakes then comment below or send me an email on: furtidev@tuta.io</a>.</p>

furtidev

Please, let my laptop sleep

Setting up Wine + Bottles on an external drive

It was worth it</h3> In the end, my Flatpak installation ended up being 6.4G and Bottles data ended up being 3.2G big. And that's without any games. I couldn't "waste" this much storage on my Linux partition. This was worth it.</p>

What's so hard about writing a JSON parser?

Trying Ghostty: My experience with terminal emulators

My experience with password managers

It was worth it</h3>
In the end, my Flatpak installation ended up being 6.4G and Bottles data ended up being 3.2G big. And that's without any games. I couldn't "waste" this much storage on my Linux partition. This was worth it.</p>