Build WebKit/WPE on Linux/X11

There’s a lot of documentation online about building Webkit/WPE on Linux. But as most instructions are targetting embedded platforms developers, the focus is on building Webkit with Wayland using the flatpak-sdk to automate and speed up the building process. As the steps I’ve followed to build it on my X11 system and run the Webkit/WPE MiniBrowser on a nested Weston were a bit different from the recommended ones I thought that a blog post about them might be useful to people trying to build WPE/Webkit in platforms lacking Wayland, flatpak, systemd, and modern Desktop Environments like the latest KDE and GNOME.

Be careful though: this is not the recommended way to build WebKit/WPE, only the alternative steps I’ve followed in my personal computer until I have access to a building machine! If you are not sure about what you want to do with WebKit/WPE please take a look at the recommended wiki instructions before you follow mine!

Continue reading Build WebKit/WPE on Linux/X11

[BootBoot]: Quick Update

Since some days ago I’ve finished BootBoot, my x86 assembly helloworld, I am posting a quick update on it and I’ll continue the blog posts when I have more time. A demo of it is on youtube:

The code is on Github: https://github.com/hikiko/bootboot
and I plan to explain it in depth in future posts in this category.

[BootBoot] Part 3: Wait for keypress

This 3rd post on BootBoot my x86 Assembly helloworld will be shorter than Part 1 and Part 2. We are going to be waiting for a key to be pressed to switch from the cyan screen of Part 1 to the purple screen of Part 2.

Continue reading [BootBoot] Part 3: Wait for keypress

[BootBoot] Part 2: Boot from a floppy drive, load the 2nd sector, jump to it

This is my second post on BootBoot, the “boot loader” I am writing to load the real boot loader after displaying something on screen. I am writing this program for fun, and to learn the x86 assembly basics. I am trying to write one blog post per commit for me to remember what I’ve done next time I need to use assembly, and for any other assembly n00b out there who might be interested in reading my steps.

In this second post, I am going to extend the program of Part 1 to load the second sector, jump to it and clear the screen with a different color after that. If the displayed color is the new one I can validate the jump was successful.

Continue reading [BootBoot] Part 2: Boot from a floppy drive, load the 2nd sector, jump to it

[BootBoot] Part 1: Boot from a floppy drive and clear the screen

Hi there! This is my first attempt to write a program in x86 assembly. I’ll call it BootBoot and it will be a boot loader that boots a program from the first floppy drive, displays an effect, and then boots grub and the OS. I am going to write a blog post after each commit to remember the steps I followed (hoping that writing my next ASM program will be easier if every step of this one is documented). In this post (part 1) my goal is to load a program that boots from the floppy drive and clears the screen.

Continue reading [BootBoot] Part 1: Boot from a floppy drive and clear the screen

FOSSCOMM 2020, and a status update on EXT_external_objects(_fd) extensions [en, gr]

FOSSCOMM (Free and Open Source Software Communities Meeting) is a Greek conference aiming to promote the use of FOSS in Greece and to bring FOSS enthusiasts together. It is organized entirely by volunteers and universities and takes place in a different city each year. This year it was virtual as Greece is under lockdown, and although we’ve missed all the fun of the gathering, there were many interesting talks to watch.

My talk was very similar to the one I’ve given in XDC 2020 about OpenGL and Vulkan Interoperability. It was an update on the EXT_external_objects and EXT_external_objects_fd OpenGL extensions status on various mesa drivers, and Igalia‘s work on them.

Continue reading FOSSCOMM 2020, and a status update on EXT_external_objects(_fd) extensions [en, gr]

A hack to display the Vulkan CTS tests output

Vulkan conformance tests for graphics drivers save their output images inside an XML file called TestResults.qpa. As binary outputs aren’t allowed, these output images (that would be saved as PNG otherwise) are encoded to text using Base64 and the result is printed between <Image></Image> XML tags. This is a problem sometimes, as external tools are required to display them. In this post I’d like to share a few simple hacks I’m using to display the CTS output as an image immediately after running a CTS test, hoping that they might be handy to more people who work on the drivers.

Continue reading A hack to display the Vulkan CTS tests output

[OpenGL and Vulkan Interoperability on Linux] Part 10: Reusing a Vulkan stencil buffer from OpenGL

This is 10th post on OpenGL and Vulkan interoperability with EXT_external_objects and EXT_external_objects_fd. We’ll see the last use case I’ve written for Piglit to test the extensions implementation on various mesa drivers as part of my work for Igalia. In this test a stencil buffer is allocated and filled with a pattern by Vulkan and then it is used in OpenGL to render something else. We validate that the pattern has been imported correctly and we repeat the process for other depth-stencil formats.

Continue reading [OpenGL and Vulkan Interoperability on Linux] Part 10: Reusing a Vulkan stencil buffer from OpenGL

[OpenGL and Vulkan Interoperability on Linux] Part 9: Reusing a Vulkan z buffer from OpenGL

In this 9th post on OpenGL and Vulkan interoperability on Linux with EXT_external_objects and EXT_external_objects_fd we are going to see another extensions use case where a Vulkan depth buffer is used to render a pattern with OpenGL. Like every other example use case described in these posts, it was implemented for Piglit as part of my work for Igalia‘s graphics team to check the extensions implementation of various mesa drivers.

Continue reading [OpenGL and Vulkan Interoperability on Linux] Part 9: Reusing a Vulkan z buffer from OpenGL

[OpenGL and Vulkan Interoperability on Linux] Part 8: Using a Vulkan vertex buffer from OpenGL and then from Vulkan

This is the 8th post on OpenGL and Vulkan Interoperability with EXT_external_objects and EXT_external_objects_fd where I explain some example use cases of the extensions I’ve implemented for Piglit as part of my work for Igalia. In this example, a Vulkan vertex buffer is created and filled with vertices and then it’s used to render the same chess board pattern once with OpenGL and once with Vulkan.

Continue reading [OpenGL and Vulkan Interoperability on Linux] Part 8: Using a Vulkan vertex buffer from OpenGL and then from Vulkan