Coding on Polaris64's blog

Writing a custom Hugo theme

Mon, 24 Aug 2020 18:33:00 +0200

I am currently in the process of creating this Hugo blog and I decided to create my own theme in order to learn Hugo internals. While testing this theme I of course needed content, so I thought “why not document the process of creating the theme as the first post in the blog?”. This is that post! Initial theme creation and set-up First steps After creating a base Hugo site with: -

Syswall: a firewall for syscalls

Sat, 16 Feb 2019 22:07:00 +0000

Links GitHub repository Motivation A while back I started thinking about software and how it does what it does. Perhaps even more importantly, I started thinking about how we can know what software does, without relying on the software’s marketing pitch. Software analysis Software can be good and can also be bad; this is what we know as malware. For malware, a lot of time and effort is spent reverse-engineering the program’s machine code in order to figure out what it does and how it does it.

My Dissertation Project

Sun, 28 Dec 2014 14:24:00 +0000

“To investigate development of an extensible 2D game engine for use by programmers and non-programmers” I am currently working on a final-year university project and dissertation and this blog is used to track my progress. I’ll post regular updates as the project progresses so please check back to see what’s happening!

Could Emacs Have a Set-up Wizard?

Mon, 28 Sep 2020 22:05:00 +0200

Introduction

There have been a number of discussions recently about modernising Emacs. Some people feel that Emacs is not aesthetically pleasing, while others feel that Emacs’s default key-bindings put off potential newcomers.

In these discussions, I normally see comments fall into two main groups: -

People who are proficient with Emacs and do not want the quest for new users to interfere with their way of using Emacs; and
People who want to welcome new users and for Emacs to be used by as many people as possible.

I agree with both groups to some extent. I consider myself a proficient Emacs user who is comfortable with the defaults and with changing them myself where necessary. However, when viewed through the eyes of a beginner, I do see Emacs as intimidating.

I strongly agree that Emacs should remain as it is and I wouldn’t want to introduce simplifications just to cater to people who might want to use it. I also don’t think that Emacs should unnecessarily try to follow the latest trends just to be “up to date”. I do however think that we can do more to provide a pathway for newcomers to follow, so this post will explore one idea for doing just that.

Hidden in Plain Sight: how attackers use obfuscation to hide code

Mon, 01 May 2017 19:10:00 +0100

Introduction Many articles, including my own, make references to code obfuscation. This article takes a look at what this actually is, as well as why it is often used by attackers to hide malicious code. What is obfuscation? Obfuscation is the process of converting something to a form where its meaning and purpose is less apparent. When related to computer source code, this can be done for many reasons; sometimes as a challenge, sometimes even for art!

Network Editor Progress

Fri, 03 Apr 2015 11:43:00 +0100

I have just finished an early alpha version of the tool, called “SG2D script editor”, which will be used to generate the Python script used to drive the engine. The tool currently has the following features: - Node-graph editor similar to Blender’s node editor, Unreal Engine 4’s Blueprint editor, etc. Ability to add custom functions Multiple game states which all build to custom classes A set of basic language nodes which allow for general Python scripting A set of engine-specific nodes providing a simple interface to the engine Colour coding for readability Pan and zoom controls Loading and saving of networks The ability to run and test the script with the SG2D engine and to view the output Here’s a video of the tool in action: - There’s still a lot of work to do, so watch this space for more updates soon!

Web Exploit Detector: NPM module

Sat, 22 Apr 2017 15:23:00 +0100

Introduction As a follow-up to the previous article about my Web Exploit Detector, I am happy to announce that I have just made the project available as an NPM module. This allows the application to be installed, used and updated much more easily than before. This article is intended to be a brief introduction to the Web Exploit Detector as an NPM module, as well as a brief introduction to NPM itself for those that are unfamiliar with it.

Engine Python Scripting Interface

Sun, 28 Dec 2014 14:55:00 +0000

My first development task was to add a scripting interface to the engine. This allows the game logic to be separated from the engine code and loaded in as with any other asset such as a sprite or audio clip. I chose Python for scripting due to its power, flexibility, popularity and ease of integration. I am using IronPython for the .NET support with XNA, but I am being careful not to introduce any .

Browser Scripting and Google Go

Mon, 21 Nov 2011 00:00:00 +0000

The latest era in the so-called “Browser Wars” seems to be focused largely on JavaScript execution speed. With more and more websites using client-side scripting to enhance functionality (Google Docs, Google Maps, Facebook etc.), the faster these scripts can run the better. Currently the most popular web browsers are Mozilla Firefox, Google Chrome, Microsoft Internet Explorer, Opera and Apple Safari. In JavaScript execution speed benchmarks, currently Chrome is at the top, with Safari, Firefox following closely for second and third and Opera and finally IE losing out with times over double that of the others.

Rust WebAssembly and JavaScript: Floyd-Steinberg Dithering

Sat, 20 Jan 2018 13:16:00 +0100

Code examples Demo Rust WASM library and HTML (GitHub) Introduction Further to my recent post comparing the performance of a WebAssembly module written in Rust to plain JavaScript and WebGL shaders for rendering the Mandelbrot set, I have added an additional example comparing the performance of WebAssembly and plain JavaScript for the Floyd-Steinberg dithering algorithm. Check out the demo! Floyd-Steinberg dithering algorithm The Floyd-Steinberg dithering algorithm is used as a way to distribute quantization errors to neighbouring pixels in an image.

Web Exploit Detector: Node.js security scanner

Sun, 16 Apr 2017 19:16:00 +0100

Introduction After detecting some new exploits on one of my web servers, I decided to start work on a new application called the “Web Exploit Detector”. This project is open-source and hosted on GitHub, meaning that it’s free for anyone to use and, more importantly, anyone can contribute their own rules to make the tool better. I now use this tool on my own servers to check for infections on a daily basis and it works well so far.

Pre-built Engine and Toolkit

Sun, 28 Dec 2014 14:36:00 +0000

For development of my project I decided to use an engine and set of tools that I have already built: the SG2D engine and the SGDK set of tools. SG2D: this is the engine itself, currently running on the Microsoft XNA Game Studio platform, allowing it to run on PC, Xbox, Windows Phone and Linux currently. SGDK: this is a set of tools used currently for asset creation (maps, animated sprites, etc).

WebAssembly and Rust: performance analysis

Tue, 09 Jan 2018 21:05:00 +0100

Code examples Demo Rust library (GitHub) Introduction I have recently been learning The Rust programming language and I absolutely love it! Rust is a systems-level language (like C and C++) which provides compile-time guarantees about memory safety and safe concurrent behaviour. Readers of my Cybersecurity and technology blogs will know that I am interested in computer security, and we’re reminded on an almost monthly basis at the moment that computer security often leaves a lot to be desired, what with vulnerabilities and exploits of public data sadly being a frequent occurrence.

Shared Canvas: the next generation

Sun, 13 Dec 2015 23:37:00 +0000

It has been quite a while since I created the original Shared Canvas, so I decided it was a good time for an upgrade… So here is Shared Canvas, mark 2! Well almost; it’s still an early alpha and there’s a lot still left to do. But feel free to have a play with it in its current state :) Currently multi-user chat and drawing is supported, and multiple rooms (with passwords) can be created.

OpenGL game: Tank Battleground

Fri, 03 Apr 2015 12:10:00 +0100

Here’s a new game that I created for a university assignment called “Tank Battleground!” The assignment required me to create a 3D game which used physics and demonstrated OpenGL and GLSL. I decided to use the idea of an arcade tank game so that I could demonstrate physics for movement (acceleration, velocity and displacement), projectile trajectories, friction, recoil, etc. The game was written from the ground up using C++, OpenGL, GLSL, GLFW, SDL_mixer, FreeImage and FreeType.

A* Path-finding

Thu, 24 Apr 2014 20:35:00 +0100

As you may or may not know, I am currently working on a game called Mendel’s Farm with the rest of the team at Static Games. Over the last couple of days I have been thinking about various ways of adding AI-controlled actors to the game and how best to make them navigate the farm… I decided that path-finding over a grid will be required to achieve this, so I decided to investigate the A* path-finding algorithm.

C#: Normal Map Generator

Mon, 07 Jan 2013 00:54:00 +0000

For a recent university assignment, I needed to create many different textures for both 3D models and surfaces. I wanted to create normal maps for each of these but I didn’t know how to do it. I decided therefore to experiment with different approaches including photographing a surface with light from different sides and by using filters in GIMP and Photoshop. Both techniques worked well and I realised that I could create a program to speed up the process.

C: Commodore 64 Emulator

Wed, 27 Jun 2012 09:46:00 +0100

This is a work in progress Commodore 64 emulator written from the ground up in C. I’m lucky enough to own an original Commodore 64 together with the technical reference manual, and using both of these I was able to create a working emulator. My first step was to code the MOS 6510 processor core. From there I coded the memory manager, the I/O, interrupt handling, the VIC chip etc. All I then needed to do was plug in the original C64 ROMs (Kernal, Character Generator and Basic) and I had bare-bones emulated C64, which was quite a thrill!

C++: "Malevolent Revenge!", Linux Allegro Game

Sun, 11 Mar 2012 00:24:00 +0000

Downloads Linux build: malevolent_revenge_linux_v1.0.0.zip (29.5KB) Windows build: malevolent_revenge_win_v1.0.0.zip (364.5KB) Source code: malevolent_revenge_src_v1.0.0.zip (38.5KB) The resource files (bitmaps, music etc), same for Linux and Windows versions, to be placed in the same directory as the executable: malevolent_revenge_files_v1.0.0.zip (14.6MB) Building from source in Ubuntu aside from the usual also requires liballegro4.2-dev and running requires liballegro4.2 and liballegro4.2-plugin-esd. Running under Windows requires alleg42.dll (included in the ZIP file) and the MS Visual C++ 2010 runtime, which can be downloaded from https://www.

Delphi (Pascal): 3D Test

Sat, 01 Jan 2011 00:00:00 +0000

This is a program I wrote in Delphi quite a few years ago. I wanted to investigate the principles of 3D graphics so I decided to create this program to explore this. All of the rendering is performed on a pixel-by-pixel basis using my own graphics routines. It is not meant to be a viable 3D engine or renderer; it’s far too slow for that due to the fact it uses Delphi’s VCL to access graphics memory.

C: SDL 3D renderer

Tue, 01 Feb 2011 00:00:00 +0000

Following on from the Delphi 3D test program, I have started to code another 3D renderer, this time in C using SDL. Again my goal is not to create a viable renderer for games, 3D applicatins etc, but rather as an exercise that will teach me more about 3D rendering. I have always been fascinated with how things work, so doing something like this will give me a better understanding to the internals of OpenGL, DirectX graphics etc.

Lishwist (beta)

Wed, 05 Jan 2022 21:50:00 +0100

I’ve just released a beta version of a new project that I’ve been working on: Lishwist! Lishwist is a web app which allows you to create and share wish-lists. There’s no registration requirement: just create a new wish-list (called a Wist) and bookmark the page! You can then share the list with others (one share per person) and these people can “claim” items to mark their intent to get the item for you.

Rust really is a superpower!

Tue, 02 Jan 2024 00:00:00 +0000

This is a small post in appreciation of Rust, the programming language, and its ecosystem. If you’ve read my other posts you’ll know that I have a strong interest in Rust. I have been using Rust for quite a number of years and I have released several posts about it, for example the performance of Rust when compiled to WASM. I’ve also built some software using Rust: Lishwist, Syswall and the Rust/WASM graphics library.

Verlet Physics Playground

Sun, 22 Sep 2024 12:51:00 +0200

I recently started playing around with the p5.js web editor and I created what I called the “Verlet Physics Playground”. That got me interested in other libraries in other languages that could be used for building real-time simulations like this. The rabbit hole I ended up in first took me to Common Lisp’s Sketch library. I love using Common Lisp and I’m especially enamoured with the interactive/REPL-driven development workflow. I had a lot of fun rebuilding the p5.