A listing of random software, tips, tweaks, hacks, and tutorials I made for Ubuntu

My tmux configuration

Since I generally work on tty’s (X barely works on my machine), I need a sort of multiplexer in order to run more than one thing at once. I have nothing against GNU Screen, but I use tmux since I have a sort of vague understanding of how it works, and so far, it has been able to handle basically everything I want.

My configuration used to simply be to change the prefix to something other than ctrl+b (since I use emacs), but a few days ago, I decided to make it look slightly prettier to me (it was actually the reason I wrote tlock yesterday :) ).

Here is a screenshot: (sorry, the dots at the bottom weren’t aligned properly, I fixed it in the post)


It’s a bit difficult to see, but the second dot (window) is amber, which indicates a bell in that window. Not the nicest color, but I was using a modified version of it for my root accont, which uses red (instead of green), so I didn’t want any confusion. But, of course, this is really easy to change :)

I’ve also changed a few keyboard shortcuts to better accomodate my workflow (such as emacs keys — ctrl+[fbnp] — to access panes, and h/v to create split windows).

Anyways, without further ado, here it is:

### Options ###

set -g base-index 1
set -g renumber-windows on

unbind C-b
set -g prefix 'C-z'
bind 'C-z' send-prefix

bind C-b select-pane -L
bind C-f select-pane -R
bind C-p select-pane -U
bind C-n select-pane -D

bind v split-window -v
bind h split-window -h

bind r source-file ~/.tmux.conf

set -g lock-command ~/ # this script contains the wrapper script mentioned in
bind l lock

setw -g monitor-activity on

### Appearance ###

set -g status-fg white
set -g status-bg default

set -g window-status-format " •"
set -g window-status-current-format " •"

set -g window-status-fg white
set -g window-status-bg default
set -g window-status-activity-fg white
set -g window-status-activity-bg default
set -g window-status-current-fg green
set -g window-status-current-bg default
set -g window-status-bell-fg yellow
set -g window-status-bell-bg default

set -g window-status-attr default
set -g window-status-activity-attr none
set -g window-status-current-attr default
set -g window-status-bell-attr default

set -g pane-active-border-fg green
set -g pane-active-border-bg default

set -g status-left "     " # padding to make up for status-right
set -g status-right "%H:%M"
set -g status-justify centre

I have the clock beside, since I use the tty, and often lose track of time :P

I personally put this in /etc/tmux.conf, then in both my main account, and the root account, I write a sort of “wrapper” tmux.conf along the lines of this: (this is what I wrote for my root account)

source-file /etc/tmux.conf

set -g window-status-current-fg red
set -g pane-active-border-fg red

You can also just use it as-is, without any problems :)

It’s very simple, but I personally really like it. Let me know if you have any ideas for it, or if you enjoy it, or anything else! ^^

tlock – Simple, but slightly prettier alternative to vlock

Admittedly, the title might seem a bit weird. I mean, it might as well say “Simple, but slightly prettier alternative to cat”. I’m still not sure how that would work (ascii boxes??) XD

So what makes this both simpler, and prettier than vlock? Well, you could try it out for yourself!! But … then this post would be entirely useless :P However, if you wish to try it out for yourself, before reading the rest, don’t let me stop you!

Anyways, let’s go back to the second paragraph. It has less features than vlock (yes, it’s possible!), and security-wise, it’s definitely not up-to-par. I’m certainly not against a bit of extra security, but it works fine for me now, so until someone needs the extra features, I will probably leave it as-is (but if you see my laptop, remember, it’s most certainly running a security-enhanced version of it … don’t touch it, you don’t want to know what will happen :P ). Second, yes, it’s prettier. Not that it’s specifically difficult to beat vlock in this aspect, but, yes, it is pretty XD

Here is how it looks like normally (if you’re wondering, it’s “password” … and if you’re also wondering, no =p)


But you can configure how both look, via environmental variables (TL_USERNAME and TL_PASS_CHAR). Here’s a slightly customized version:


Trust me, if you run this on a tty, with ter-112n (smallest font size of terminus — excellent coding font!), it will look amazingly slick :D (at least, in my biased opinion, it does!). There’s very little in this world that spells “awesome” better than root with red letters, with red dots below, surrounded by a vast array of blackness XD

So how do you install this thing? Clone the git repo, build, and install. It’s important that you install, since the application requires setuid privileges to check your password. Or you could just sudo chown root tlock;sudo chmod u+s tlock too. For copy&paste convenience:

git clone
cd tlock
mkdir build
cd build
cmake ..
sudo make install # or sudo chown root src/tlock; sudo chmod u+s src/tlock

Now that it’s built/installed, all you need to do to run it is, quite simply, run it. It will automatically detect your username, and will hopefully work exactly as planned. However, if you want it to customize it a bit, here’s what I wrote for a wrapper script: (change to your liking :) )

export TL_USERNAME="`echo -e '\e[32m'`MiJyn`echo -e '\e[0m'`"
export TL_PASS_CHAR="`echo -e '\e[32m'` •`echo -e '\e[0m'`"

It just uses standard ANSI escape sequences for the colors, see here:

Let me know if you have any issues, or feature requests, or anything else! I’m not particularly invested in this project (since it is such a simple one), but I would be glad to help if anyone needs something for this :D

Collaborative Track Idea

I really, really want to make open-source music. Or rather, open-source musical projects. Software is never truly finished… and neither is music. It’s difficult to do it though, since the way music is written now, it’s very difficult to make a highly open collaborative environment. I want to change this (and I’ve been working on this in various areas for about 2 years), but, that’s for another post.

This post is actually for a step down from this idea. It’s not open-source, since I don’t think I can legally share the samples or plugins or anything else required. My DAW and plugins are sadly not open-source (let alone libre) either, so I don’t know what the project file has contained, and therefore, I don’t think I can share that either. The track will be released under a CC license though (I’m thinking BY-SA).

However, it’s still the same sort of idea in concept. It’s the idea of people working together and sharing ideas in order to make a track, and one person, the lead artist, implementing the ideas (and, of course, everyone gets credited fully for the work they did). Though I am suggesting this for one of my own tracks, I would personally love to work on an environment like this, for other musicians as the lead artist (in fact, I would probably prefer this, since I’m not very good myself).

My idea is to create this track in this manner, and hopefully inspire other musicians to do the same.

What I have so far of the track is here (the description contains basically the same information as provided in this post) … and no, don’t worry, it won’t be about ponies XD For now, it’s a remake of a MLP-themed track I did 2 years ago, but it will be its own track, entirely separate from ponies (though still musically inspired from the first track):

Why Openlux instead of Redshift?

First, I want to clarify that this is not a post trying to show that one is better than the other unequivocally. This is, instead, a post trying to show my reasons for writing openlux, and the differences between both softwares. I’m sure that many people will prefer the way that redshift works, over the way that openlux works, and that’s awesome!! The purpose of this post is, mainly, to show the differences, and hopefully help you decide which is better for your circumstance :)

My initial reason for writing openlux was because f.lux didn’t work for me, for various reasons (as I outlined in the first post about it) … I was actually unaware of redshift. There were a few people who linked me to it, and I immediately felt slightly disappointed that I hadn’t done my research before (would have saved me quite a bit of work!). Looking into it though, it’s not what I was looking for, and it has some of the issues that made me switch away from f.lux.

Redshift’s mode of operation is different than openlux’s. It primarily functions as a daemon, changing the color temperature automagically, depending on your timezone. This is a really handy feature, however, you don’t have much ability to configure the times. If you don’t have insomnia, and have a regular sleeping schedule, this is probably perfect. You tell it where you live, and it will change the screen color temperature throughout the day, in order to match the light you would receive if you were outside at that time (except at night, of course =P). But in my case, I can stay up until 4-5am, unable to sleep at all. Having the screen automatically change to a higher color temperature when I’m trying to go to sleep is most definitely not what I need. Now I could change the timezone every so often, but I’d rather have something in which I control when the screen color changes, instead of having to work against the program. I am aware that redshift has an option for manually changing the color temperature, but you don’t have much control over other options (such as animating to it, or individual control over RGB channels).

Redshift also uses color tables in order to compute the RGB values from kelvin temperatures. This allows for maximum accuracy within the range it provides (1000-25100K), however, it doesn’t allow anything outside of the range. On the other hand, openlux, works using Tanner Helland‘s algorithm, which allows for a theoretically infinite (practically 0-232, because it’s stored in a 32-bit integer), but less accurate result. Personally, I prefer using an algorithm, but there are definitely things to say about using a color table instead. The algorithm is pretty accurate (I think it’s a maximum of ~3-5% off of the original value), but if you’re within the range that redshift provides, it’s always nice to have 100% accuracy!

The main philosophical difference (that influences how the programs evolve) between redshift and openlux is the goal: redshift is more oriented towards being a standalone, fully-featured program, while openlux is oriented towards being a program that only does one task (change the screen color temperature), and focuses on that one task. It leaves tasks such as changing the color temperature in accordance with the timezone to other programs specialized for this (such as cron), or manually. Redshift tends to go more on the side of “run it, and forget about it”, while openlux leans more on giving the user maximum control and flexibility.

There’s definitely something to be said about both philosophies, and different users will appreciate different philosophies. I personally prefer the one of having full control at all times, but there are many users who would prefer to just have the program manage it for them automagically.

If you’re not sure which to use, try both! See which one works best for you. After all, GNU/Linux is all about choice :)

If I’ve made any mistake in this article, please let me know. This post is most definitely not about saying that one software is better than the other. While I, of course, prefer openlux, I want this to be a fair comparison of both softwares, so that users can better decide which software they want to use for themselves.

Openlux 0.2 beta – Animations, iOS port

I wrote openlux around 2 and a half weeks ago, as a simple, libre alternative to f.lux that addresses a few issues I’ve encountered with it. I’ve since used it everyday, and I’ve actually noticed an improvement in my sleep!

However, my iPad still uses f.lux (or, until today, at least). No, in this case, I’m not worried about the fact that f.lux is proprietary (it’s an iPad), but earlier, when my sleep was really messed up (and by messed up, I mean, I was going to sleep at 7-8am), f.lux would automatically switch to 3400K (instead of 2300K), which definitely didn’t have a positive impact on my sleep. Also, it only goes down to 2300K, doesn’t allow much customizability, and doesn’t always work how I want it to work, etc.

So after spending quite a long time (basically ever since I released the first version of openlux) working on the port, it finally works!!! It doesn’t work as well as I wanted it to (multiple colors output the same value, compressing the color range … I tried lerping values, but it ended up giving garbage), but at least it works!

Animations literally took about the last hour of developing this version (in other words, barely any time at all, compared to the time needed to develop the iOS port), since, luckily, I only encountered one bug while making it. The point of animations is not for visual bling, but rather to make it easier on the eyes if it’s run automatically (e.g. via cron).

Other than those, there are a few minor features, such as optional relative adjustment of colors (“-b 10” will set the blue channel to 10, “-b +10” will add 10 to the blue channel, and “-b -10” will remove 10), and saving/resetting gamma values (mainly just a by-product of working on the iOS port).

If anyone would be interested in testing this on their iDevices, I would really appreciate it ^^ Though it works fine on my 1st generation iPad, I don’t know if it will work on other devices too. I wrote instructions on how to compile and run it here: :) I’m not aware of this being able to cause any permanent damage to your device (my device works fine now, even after the display being severely messed up multiple times), but if you’re scared, stick with f.lux for now. Quick note: it doesn’t work on iOS <4, since it needs to retrieve the gamma table (which iOS versions <4 don’t support).

To wrap up, here’s a few examples of the new features that come with openlux 0.2:

openlux -k 1000 -a 10000         # Animates to 1000K in 10 seconds (10000 milliseconds)
openlux -k 1000 -a 100000 -d 100 # Animates to 1000K in 100 seconds, with a delay of 100 milliseconds per "frame" (less CPU usage)
openlux -k 1000 -g +10           # Sets the color temperature to 1000K, but adds 10 to the green channel
openlux -R                       # Resets to the last saved gamma table (openlux automatically saves the gamma table the first time it's run per boot)
openlux -s                       # Saves the gamma table

Follow up on the non-windowing display server idea

Note: I’m sorry, this post is a bit of a mess.

I wrote a post 2 days ago, outlining an idea for a non-windowing display server — a layer that wayland compositors (or other programs) could be built upon. It got quite a bit more attention than I expected, and there were many responses to the idea.

Before I go on, I wish to address a few things that weren’t clear in the original post:

The first being that I am not an ubuntu developer, and am in no way associated with canonical. I am only an ubuntu member :) Even though I don’t use ubuntu personally, I wish to improve the user experience of those who do.

Second is a point that I did not address clearly in the original post: One of the main reasons for this idea is to enable users to modify the video resolution, gamma ramp, orientation, brightness, etc. DRM provides an API for doing these operations, however, AFAIK, you cannot run modesetting operations on a virtual terminal that is already running an application that has called video modesetting operations. In other words, you cannot run a DRM-based application on an already-running wayland server in order to run a modesetting operation. So, AFAIK, the only way to enable an application to do this is to write a sort of “proxy” server that handles requests, and then runs the video modesetting operations.

Since I am currently confusing myself re-reading this, I’ll try to provide a diagram in order to explain what I mean.

If you want to change the gamma ramp, for example, this is impossible:


So with the display server acting as a proxy of sorts, it becomes possible:


This is also why I believe that having a server over a shared library is crucial. A shared library would allow for abstraction over multiple backends, however, it doesn’t allow communication with more than one application. A wayland compositor can access all of the functions, yes, but wayland clients cannot.

The third clarification is that this is not only meant for wayland. Though this is the main “client” I have in mind for this server, it isn’t restricted to only wayland. The idea is that it could be used by anything, for example, as one response pointed out, xen virtualization. Or, in my case, I actually want to write clients that use this server directly, without even using a windowing server like wayland (yes, I actually have a good reason for wanting this XD ). In other words, though I believe that the group that would use this the most would be wayland users (hence why I wrote the original post tailored towards this), it isn’t only meant for wayland.

There were a few responses saying that wayland intentionally doesn’t support this, not because of the reason I originally suspected (it being “only” a windowing protocol), but because one of wayland’s main goals is to let the compositor to have full control over the display, and make sure that there are no flickers or tearing etc., which changing the video resolution (or some other modesetting operations) would undoubtedly cause. I understand and respect this, however, I still want to be able to change the resolution or gamma ramp (etc.) myself, and suffer the consequences of the momentary flickering or whatever else. Again though, I respect wayland’s decision in this aspect, so my proposal, instead, is this: To make this an optional backend for wayland compositors. Instead of my original proposal, which was to build wayland compositors on top of this (in order to help simplify the stack), instead, have this as an option, so that if users wish to have the video modesetting (etc.) capabilities, they can use this backend instead.

A pretty large concern that many people (including myself) have is performance. Having an extra server on the stack would definitely have an impact on performance, but the question is how much.

So with this being said, going forwards, I am currently working on implementing a proof-of-concept prototype in order to have a better sense of what it entails, especially in regards to performance. The prototype will be anything but production-ready, but hopefully will at least work … maybe XD .

Idea: Non-windowing display server

For the TL;DR folk who are concerned with the title: It’s not an alternative to wayland or X11. It’s layer that wayland compositors (or other) can use.

As a quick foreward: I’m still a newbie at this field. While I try my best to avoid inaccuracies, there might be a few things I state here that are wrong, feel free to correct me!

Wayland is mainly a windowing protocol. It allows clients to draw windows (or, as the wayland documentation puts it, “surfaces”), and receive input from those surfaces. A wayland server (or “compositor”) has the task of drawing these surfaces, and providing the input to the clients. That is the specification.

However, where does a compositor draw these surfaces to? How does the compositor receive input? It has to provide many backends for various methods of drawing the composited surface. For example, the weston compositor has support for drawing the composited surface using 7 different backends (DRM, Linux Framebuffer, Headless [a fake rendering device], RDP, Raspberry Pi, Wayland, and X11). The amount of work put into making these backends work must be incredible, which is exactly where the problem relies in: it’s arguably too much work for a developer to put in if they want to make a new compositor.

That’s not the only issue though. Another big problem is that there is then no standard way to configure the display. Say you wanted a wayland compositor to change the video resolution to 800×600. The only way to do that is to use a compositor-specific extension to the protocol, since the protocol, AFAIK, has no method for changing the video resolution — and rightfully so. Wayland is a windowing protocol, not a display protocol.

My idea is to create a display server that doesn’t handle windowing. It handles display-related things, such as drawing pixels on the screen, changing video mode, etc… Wayland compositors and other programs that require direct access to the screen could then use this server and trust that the server will take care of everything display-related for them.

I believe that this would enable for much simpler code, and add a good deal more power and flexibility.

To give a more graphic description (forgive my horrible diagraming skills):

Current Stack:


Proposed Stack:



I didn’t talk about the input server, but it’s the same idea as the display server: Have a server dedicated to providing input. Of course, if the display server uses something like SDL as the backend, it may have to also provide the input server, due to the SDL library, AFAIK, doesn’t allow a program to access the input of another program.

This is an idea I have toyed around with for some time now (ever since I tried writing my own wayland compositor, in fact! XD), so I’m curious as to what people think of it. I would be more than happy to work with others to implement this.

Using Openlux to help your sleep and/or relax your eyes

If you are familiar with research suggesting that blue light affects your sleep, you might also be familiar with a (free!) software named f.lux. I use it on my iDevices (used to use it on my computers too), and it works great …. except for a few issues.

The first is CPU consumption. Seriously, this software takes up a lot of CPU. That was the main reason behind ditching xflux (the X11 edition of the software). It also doesn’t entirely block out blue light, even at the lowest color temperature it allows (this is true for the iOS version too). There were a number of other issues that became annoying over time (forced very long animations, a daemon that rarely ever works as intended, sometimes the software doesn’t even work at all, mouse cursor being left entirely out of the picture, etc.). These would (probably) all be simple to fix …. however, it’s free as in price, not as in freedom. The software is closed-source.

Openlux is a very simple open-source MIT-licensed clone I wrote that tries to address these issues (minus the mouse cursor issue, that one is a bit more complex). For now, it doesn’t contain as many features as xflux does, but it is only a first release. Animations and the lot will come later :)

I haven’t worked on packaging yet (if anyone wishes to spend some time doing this, that would be greatly appreciated!!), but for now, visit for download and compilation information (sorry for the mess in main.c, I will get to that later!).

Here are a few usage examples

openlux                      # Sets the screen color temperature to 3400K (the default)
openlux -k 1000              # Sets the color temperature to 1000K
openlux -k 2000 -b 0         # Sets color temperature to 2000K, but removes all blue light
openlux -k 2000 -b 255       # Ditto, but blue is set to 255 (maximum value, gives the screen a magenta-ish tone)
openlux -r 130 -g 150 -b 100 # Gives the screen a dark swamp green tint (Kelvin value is ignored)
openlux -k 40000             # Sets the screen color temperature to 40000K
openlux -i                   # Resets the screen color temperature

I personally like using openlux -k 10000 during the day (very relaxing for the eyes!), and openlux -k 2300 -b 40 during the night.

I hope this can be useful for you!! If you have any issues, suggestions, feedback, etc. (even if you just want to say thank-you — those are always appreciated ^^), feel free to write a comment or send me an email!

The importance of freedom in software

Software license agreements (EULA) are generally considered little more than a confirmation on whether or not the user really wants to install said software. Heck, for all that most users care, it could read “Do you wish to install this software?” and their overall reaction would be approximately the same. In fact, I often catch myself using the “I decline” button when I realize that this software is indeed useless.

Of course, in the back of our minds, we know that we really should read it …. but, come on, we have a life to live. We can’t spend it reading license agreements! YOLO.

Many software developers know this fact, and capitalize on it. One good example would be a company named after a fruit that develops smartphone specifications. Have any of you ever read the 60 page long license agreement on a tiny screen, just to install the next Flappy Bird?

I’m no different. I’ve probably only read 3 (proprietary) license agreements in my entire life… and I’ve installed hundreds of proprietary software.

I’ve also found myself accustomed to thinking it’s illegal to share software with my friends. The idea of inspecting or modifying how a proprietary software works (through reverse engineering) feels very risky and only borderline legal. And, actually, both are true in most cases.

For many users, this doesn’t seem like an issue. Most users, and in fact a lot of programmers too, wouldn’t check the source code of a program they are running. And, to be honest, most users would rather just link to the website of the software anyways, even if the software would allow itself to be shared.

However, just because these freedoms are rarely used, it doesn’t mean that they are useless. Think of a self defense class. Unless you’re in a more violent neighborhood, chances are that you will very rarely need to use it. But when you do, you will be really happy that you did invest the time to learn it. After the Snowden leaks, many people started accusing software of sending data to the NSA. Is this true? I don’t know. And that’s the issue: We are not legally allowed to know. We cannot inspect or modify the software in any way. We blindly trust what the developers say about their products.

Of course, there are also more everyday usages of being able to inspect, modify, or share. I’ll use Studio One as an example. It’s a proprietary software. Its bugs have lead me to immense data losses (due to a really badly functioning “Undo” button that can occasionally screw up the entire project file). If I had the source code handy it would be possible to fix this (probably a bit difficult, yes, but possible). But I can’t fix it, because the EULA doesn’t allow me to inspect and modify.

What about sharing software? Because I cannot share the software I use with others, it makes it entirely impossible for me to create truly “open source” music (I’m not sure if the term applies to music, but I think you get the idea). I make breakdown videos, where I show how I made the music, but as far as I know, I cannot legally go any further than that.

This is not because these software developers are evil. They do this to maximize their profits, and that’s understandable. However, the cost of this is our freedom.

Now that I’ve spent some time criticizing proprietary software, I’ll take a bit of time promoting free (as in freedom) software.

First the term, Free Software. “Free” has multiple meanings (in the coincidentally named “”, it lists 38 different meanings for the word “free”), but there are 2 major ones: free as in no price (gratis), and free as in freedom (libre). In order to distinguish between them, I’ll use “gratis” and “libre” instead.

Both the terms gratis and libre can be used to describe software. Hence, using the term “free” can be very ambiguous; “does this specific software respect my freedom? or is it just that my wallet is unnecessary?”. In many software circles, “free software” simply means gratis. In these circles, Skype could be considered free software (even though it doesn’t respect your freedom, among other issues). However, in other circles (generally among libre software developers), “free software” qualifies as “libre”, not “gratis” (and therefore, Skype would not be considered free software).

So what is the purpose of free software? Basically, depending on the license, it enables you to do what proprietary software forbids you from doing. You can share the software with anyone, you can inspect how the program works, you can modify it, and you can redistribute the modified versions too! It allows for an incredible eco-system in which programmers around the world can create new features, fix bugs and security leaks, then submit it back to the project leader for integration with the software. Or, if someone has a wildly different goal than the team who develops the project, they can fork it and create a new project, using a modified codebase of the original!

What does this mean to users who don’t know how to program? Well, okay, sure, not as beneficial to them. However, practically speaking, since an unlimited amount of programmers can get involved, libre software (especially larger ones) have a much lesser chance of having bugs, security leaks, viruses, or spyware. It can also include many more features than proprietary software does. Libre software is also often updated much more frequently than proprietary software, since any developer can contribute.

It is also possible for users to hire a programmer to make a change for them, in the same way that home owners may hire a plumber to fix a leak (except that, generally speaking, programmers would probably take more time to make the change than a plumber would to fix the leak).

Since the first part talked about the idea of proprietary software, and the second about free/libre software, the third will look at practical usage: How to switch over to libre software.

It can be difficult to switch to libre software, especially when you have proprietary software that you use a lot and/or really like. For example, if you use Skype, it may be difficult to ask your Skype contacts to switch over to Ekiga or some other libre VoIP software. In my case, a surprising number of my contacts were thankfully flexible enough to switch over to some other communication method. However, everyone is individual, and your friends might find it difficult to migrate over (even after explaining why not to use Skype).

However, luckily, most proprietary software have libre equivalents. It is beyond the scope of this post to list these, but, with a bit of research, you can find some online (I would link a list, however, I can’t find any lists that only include truly libre software). I would be happy to help find an alternative if you want too! (just leave a comment or send me an email)

Sometimes though, there are no alternatives. This is especially relevant in the field of modern video games, or music production. It is also relevant with drivers for parts of your system that do not have a libre driver written for it. So what do you do? This is really up to you. Are you okay with using proprietary software for this one purpose? Should you avoid using it period?

For me, I use proprietary software for both music production, and a few video games. I don’t like the fact that I’m using either, but I currently value the features that it provides over what it can control (when using proprietary software, I ensure that internet is turned off, and I don’t have any other software open). Later, once I find OSS alternatives for the music software I’m using, and when I detach myself from video games (I only really play Deus Ex Human Revolution …. it’s a good game, with an amazing soundtrack xD), I will probably finally use 100% libre software (minus the BIOS) on all of my machines.

Lastly, I would like to address the fact that libre software is only one part of the issue in having control over your computer. While it is possible to have full freedom in every single way for software, there are two other major issues: Hardware, and Internet.

Hardware is very difficult, since you can’t easily change the hardware. And, in fact, even if you knew the source code (HDL) of the hardware, it would be very very difficult to reverse engineer it in order to make sure that the hardware is indeed following the source code. There are even theories that Intel and AMD CPUs are sending information to the NSA (evasively worded responses from the companies give credence to this theory). Whether or not this is true is outside the scope of this article, but the point is, hardware is a very big issue, and I think the only true answer that would guarantee that the source code truly is the hardware, would be to create your own hardware. I think it goes without saying that this would be very very difficult. Maybe with the rise of 3D printers this will someday change … who knows!

Internet is the other issue. The internet is a way to access ports from foreign computers. Unless you own the foreign computer, there is no way of guaranteeing that your data will be safe with them. They can do anything they want with the data you send. Getting away from services that are known to spy on you and otherwise harm you (such as Facebook) can be a difficult task, depending on how connected you are with the service. In Facebook’s case, everyone is on Facebook, because everyone is on Facebook. Leaving it can be difficult, since you have to sometimes migrate family members and friends to other websites (same point as I made with Skype).

I hope that you found this post useful! I’m sure a lot of points in here may be wrong (please correct me!!), but I have tried my best in order to make sure that this can be as informative and accurate as possible to those that are new to the concept of software freedom. I know I have missed a lot of other important points in here, but I’m not sure where, or if they should be mentioned, so I will link articles containing those below.

If you have any questions, comments, corrections, or anything else (as long as it is constructive, of course!), please feel free to leave a comment or send me an email!

Further reading: (a very good explanation on what the Free Software Foundation considers libre software) (a talk by Richard Stallman, founder of the GNU project, about software freedom) (a list of completely libre GNU/Linux distributions) (a list of software that are free and open-source, but not libre … yes, Linux contains non-free code!)

Track: Dawn of a new Era

I made this track a while back, and I hope you’ll enjoy it! =D Linux-wise? Umm … it was made on a linux machine … using wine for like, everything …. but it was on a linux machine!! =p Spent ~60 hours on this.


Get every new post delivered to your Inbox.

Join 182 other followers