content/articles/blaze-lisp.md

@@ -1,20 +0,0 @@
----
-title: "blaze lisp"
-description: "An implementation of the MAL (Make a Lisp) project."
-navigation: false
-date: "2023-03-18"
-img: "/img/.png"
-tags:
-  - C++20
-  - CMake
-  - Software
----
-
-<small>An implementation of the MAL (Make a Lisp) project.<br>
-Repository at
-[GitHub](https://github.com/riyyi/blaze){target="_blank"},
-[GitLab](https://gitlab.com/riyyi/blaze){target="_blank"} or
-[Gitea](https://git.riyyi.com/riyyi/blaze){target="_blank"}.
-</small>
-
-TODO

content/articles/garbage.md

@@ -1,33 +0,0 @@
----
-title: "GarbAGE (Garbage Accurate GameBoy Emulator)"
-description: "GameBoy Emulator that is not that accurate."
-navigation: false
-date: "2022-08-17"
-img: "/img/garbage.png"
-tags:
-  - C++20
-  - CMake
-  - Software
----
-
-<small>GarbAGE (Garbage Accurate GameBoy Emulator).<br>
-Repository at
-[GitHub](https://github.com/riyyi/garbage){target="_blank"},
-[GitLab](https://gitlab.com/riyyi/garbage){target="_blank"} or
-[Gitea](https://git.riyyi.com/riyyi/garbage){target="_blank"}.
-</small>
-
-This is an exploration into emulators by me and a friend of mine. The only thing
-thats really implemented are the CPU opcodes. The cool thing however, is that
-for the rendering portion of the application we are using my own
-[game engine](/articles/inferno)! No other libraries were used.
-
-The simplest game to test is Dr. Mario and even that one doesnt render
-correctly, but we do get graphics that you can make out, pretty cool!
-
-![garbage](/img/garbage.png "garbage")
-
-Preview video of the boot sequence and intro of the Dr. Mario game.
-
-::VideoLazy{:src="/img/garbage-preview.webm"}
-::

content/articles/utility-library.md

@@ -24,128 +24,11 @@ my projects and create one cohesive style.
 
 ## Argument parsing
 
-This is a simple argument parsing feature, with the attempt of making it simpler
+placeholder
-to use than getopt. All you have to do is specify the variables you want to use,
-then add the options and arguments on the `ArgParser` object and finally call
-the `parse` function.
-
-```cpp
-#include <string>
-#include <vector>
-
-#include "ruc/argparser.h"
-
-int main(int argc, const char* argv[])
-{
-	bool verbose = false;
-	std::vector<std::string> targets {};
-
-	ruc::ArgParser argParser;
-	argParser.addOption(verbose, 'v', "verbose", nullptr, nullptr);
-	argParser.addArgument(targets, "targets", nullptr, nullptr, ruc::ArgParser::Required::No);
-	argParser.parse(argc, argv);
-
-	// Do some work here..
-
-	return 0;
-}
-```
-
-The `nullptr`'s in the above example were going to be used for automatic help
-string generation, but that isn't implemented yet.
 
 ## Formatting library
 
-This is basically a partial copy of the `fmt` library, from before that became
+placeholder
-part of the C++20 standard and I didn't want to use an additional dependency in
-my projects, because that is less fun!
-
-The part of `fmt` that is implement is the
-"[mini-language](https://fmt.dev/11.1/syntax/#format-specification-mini-language)",
-which is a very convenient API.
-
-```cpp
-#include <string>
-
-#include "ruc/format/format.h"
-#include "ruc/format/print.h"
-
-int main(int argc, const char* argv[])
-{
-	std::string fmt = format(
-		R"(
-	number {}
-	string {}
-	bool {}j
-	double {}
-	double {:.2} with 2 precision
-)", 123, "this is a string", true, 456.789, 3.14159265359);
-	print("{}\n", fmt);
-
-	return 0;
-}
-```
-
-Which results the the output.
-
-```
-	number 123
-	string this is a string
-	bool true
-	double 456.789000
-	double 3.14 with 2 precision
-```
-
-The implementation consists of 2 major parts, the parsing of the format string
-and the `format` and `print` functions. The parsing part isn't that complex, so
-wont be discussed here. The other secion is interesting, however.
-
-The functions are implemented with variadic arguments using type erasure, this
-improves both compile time and binary size significantly. What it also does, is
-allow the library to work on types that are specified by the user and are
-therefor not part of the library.
-
-The formatter implements all the primitives and some of the STL types, it can be
-extended by the user. The basic use-case is to specify to just the `format`
-function, but the `parser` function can also be overwritten.
-
-```cpp
-// In the header we are extending the existing formatter for vectors,
-// so we take advantage of their nice formatting automatically
-template<>
-struct ruc::format::Formatter<glm::vec4> : Formatter<std::vector<float>> {
-	void format(Builder& builder, glm::vec4 value) const;
-};
-
-// Then in the implementation, we implement the format functon
-void ruc::format::Formatter<glm::vec4>::format(Builder& builder, glm::vec4 value) const
-{
-	return Formatter<std::vector<float>>::format(builder, { value.x, value.y, value.z, value.w });
-}
-```
-
-Users can even extend formatters based on their own formats. In this example we
-are extending the vector (`glm::vec4`) formatter, so we can also print matrices
-(`glm::mat4`).
-
-```cpp
-template<>
-struct ruc::format::Formatter<glm::mat4> : Formatter<glm::vec4> {
-	void format(Builder& builder, glm::mat4 value) const;
-};
-
-void ruc::format::Formatter<glm::mat4>::format(Builder& builder, glm::mat4 value) const
-{
-	builder.putString("mat4 ");
-	Formatter<glm::vec4>::format(builder, value[0]);
-	builder.putString("\n     ");
-	Formatter<glm::vec4>::format(builder, value[1]);
-	builder.putString("\n     ");
-	Formatter<glm::vec4>::format(builder, value[2]);
-	builder.putString("\n     ");
-	return Formatter<glm::vec4>::format(builder, value[3]);
-}
-```
 
 ## JSON parsing