Part 1 -

I am blessed to announce that I have been selected for Google Summer of Codes 2020 with GCompris! I would really like to thank my mentors for giving me this opportunity.

So yeah, I am really excited to begin one more journey with Gcompris after successfully completing SoK this year. loads of fun and a very productive summer is waiting for me ahead. I am ready to grasp it with both hands.

I would say the key factor for my selection in GSoC is my involvement with community. I have been contributing since last December, I was active on IRC, discussing stuffs and also submitted my proposal for reviews, quite early which gave a decent amount of time to mentors to review it properly and suggest appropriate changes.

Stay tuned, I will share my goals and further journey with Gcompris in upcoming blogs.

Krita and me

Saurabh Kumar posted at 17:25 confifu

Hello folks, I am Saurabh (irc:confifu), a new contributor of Krita. In the improbable case that you are ill informed about Krita, here you go:

Krita is a free and open source digital painting application. It is for artists who want to create professional work from start to end. Krita is used by comic book artists, illustrators, concept artists, matte and texture painters and in the digital VFX industry.

In the probable case that you are ill informed about me 😛 , I am a 2nd year Computer Science undergraduate student at Delhi Technological University. My hobbies include running, reading books, drawing and painting.

Krita is my first interaction with the open source community and the experience has been truly spectacular. The community of developers and artists around Krita is very warm and friendly. They answer the dumbest of your questions. Starting from helping me build Krita to getting my GSoC proposal ready, they were always helpful. I feel like I have been nurtured by this community to have a more open minded perspective. I have seen how patiently they answer questions that are asked by me and others, no matter how stupid it may sound, and this has made me kinder to people. I am no more the cold fish that I used to be, the warmth is changing me. Krita has enabled me to use my skills to solve problems that would help a lot of people. The effect of open source is not only limited to my development skills, it has spilled over to other parts of my life as well.

On the more technical side, I have become more confident with multiple files, classes and functions that interact with each other in complex manner. I have become better at finding and understanding the code that affects the relevant problem. I have learned the value of good documentation and good comments. The feeling of gratitude towards the developer when trying to understand a piece of code and finding a relevant comment is immense.(Note to self: write good comments). I have a lot to learn, and after contributing to Krita I have gained a new confidence in my ability to learn.

I have been selected to participate in GSoC 2020 to work on a Storyboard docker for Krita. I would be mentored by Agata Cacko, Boudewijn Rempt and Scott Petrovic. This project would aim to build a storyboard docker that would let animators and storyboarders create a storyboard easily and quickly. They would also be able to export the storyboard in commonly used formats. I look forward to working with my mentors and the community to complete this project.

Link to the Phabricator Task , project listing the full proposal. Feel free to share any ideas and/or suggestions. 🙂


8 May, 2020

It has been over a year since I made my first contribution for KDE and I truly loved every bit of it since then. It all started from October 2018 when I was trying to get habitual of using Linux as it is good for development but ended up in really hating it, due to its Desktop environment. Then, I tried KDE plasma and fell in love with it. I began exploring various KDE projects and really loved the work that the community is doing. I really wanted to be a part of it.

I tried out using Elisa and was really mesmerised by its beautiful user interface. I then began contributing to the same project and then started working for Krita.

I applied for GSoC 2019, but was rejected due to lack of slots for the organisation. Though I was sad, I trusted my mentor's decision and I made into the program this year.

Coming to my project, I will be working on Integration of MyPaint brush engine in Krita. MyPaint developers have separated out their brush engine in the form of a library Libmypaint. Since then, the brush engine has been integrated in most of the painting applications. Integrating the same in Krita will enable artists to work with MyPaint brushes which they love a lot.

I will try to give my best in the project this summer and I don't care about the end result of GSoC as I finally am a part of KDE community.  

I’m really excited to announce that my proposal for participating in GSoC 2020 with DigiKam has been accepted! I would like to thank the developers for considering me worthy of this opportunity.

I came to know about KDE during December 2019, when Season of KDE was announced. Even though my proposals for SoK were rejected, I’m glad I didn’t lose hope! I spent the months of January and February getting used to compiling from source, and the GitLab workflow. I learnt many lessons along the way, such as how copy pasting any command you find on StackOverflow into your terminal, can sometimes be disastrous.

DigiKam is a photo managing software, which does a lot more than just group your photographs. The latest version provides an impressive Facial Recognition utility, which makes use of Deep Neural Networks to automatically detect and recognize faces. My project aims to improve the workflow of the Facial Detection and Recognition process, in order to make the overall experience much better for the user.

The official coding period begins from June 1, however I may have to start with my project before that. Due to the current global situation, my university was forced to shift examinations to early July. This interferes with the timeline I had proposed initially, however I’m determined to make things work.

0 GXeaiRPePMjHuuHZ

Hello everyone, I am Deepak Kumar a 3rd-year undergraduate student pursuing B.E in Information Technology from India.

I am happy to share that I have finally cracked Google Summer of Code this year. My project titled “Adding Multiple Datasets to several Activities” has been selected by KDE GCompris organization.

I have been contributing to the GCompris project from the past year. The day when I started contributing to GCompris I was new to open-source. GCompris was the first organization I started to contribute in the field of open-source. I took up the basic issues initially and gradually when I was enough comfortable with the codebase I worked on resolving many issues, adding features to this awesome project. I have also completed Season of KDE 2020 on which I have worked on implementing multiple datasets to few activities. I think that the main reason for the selection of my application would be that I am well familiar with the codebase, implemented multiple datasets to a few activities, community involvement and an active contributor for this project.

Coming to my project on which I will be working during the GSoC period. I will be working to add multiple datasets to several memory activities, guess-count activity and mirror the given image activity.

I am thankful to all of my mentors for this opportunity and the help and support I have got with all of them as a contributor.

Looking forward to great summer ahead with a lot of learning :)

Deepak Kumar


7 May, 2020

Go is one of the best languages to write a parser and tools that need some form of parsing in. This is mainly due to:

  • Great string and regexp functions in the stdlib for parsing
  • Easy and safe introspection for blank interfaces (Go's equivalent of a QVariant or a void pointer)
  • Labels. You have both gotos and the ability to break and continue deeply nested loops, which is great for handwritten parsers.
  • Fast compilation makes for fast iteration.

Screw XML

XML is unwieldy to write and obtuse to read. Unfortunately, things like Wayland use it for protocol descriptions. Fortunately, Go can be used to author tools that generate XML from a more human-readable format.

Introducing the Participle

Participle is a Go library that makes writing and parsing data into ASTs extremely easy. I'll demonstrate a simple usage of it for authoring a better Wayland protocol syntax that can transpile to XML.

One: Designing a syntax

This is mostly up to your opinion: I like the aesthetic of Go, so I went with a very Go-like aesthetic:

protocol appmenu

interface zxdg_appmenu_v1 {
    version 1

    request set_address(service_name string, object_path string)

Simple, yet descriptive.

Two: Building trees

Participle by default uses the tokens that form the Go language itself, which is important to know. A grammar has to play by Go rules if you stick with the default tokens.

Let's start by defining a simple protocol struct:

type Protocol struct {

It's empty, which isn't very useful. Let's give it a name element since we want to be able to name our protocol.

type Protocol struct {
    Name string

This looks like a nice start to our tree, but how does the parsing work? We add some metadata.

type Protocol struct {
    Name string `"protocol" @Ident`

This will tell Participle two things:

  1. It should look for the string protocol in our protocol grammar
  2. It should grab the next Identifier token and put it into the field

Now, we probably want to add a hook for an interface, as a protocol without interfaces is useless. Let's write that in:

type Protocol struct {
    Name       string      `"protocol" @Ident`
    Interfaces []Interface `{ @@ }`

The { @@ } will instruct the parser to capture as many interfaces as it can and stuff them into the array.

Now let's write a description for what we want an interface to look like, starting with a name.

type Interface struct {
    Name   string     `"interface" @Ident "{"`
    // Put the goodies here!
    Ending struct{}   `"}"`

The purpose of the Ending field is to make sure that our interfaces end with a closing bracket.

An interface is composed of requests. Let's take a closer look at what our design looked like:

request set_address(service_name string, object_path string)
| always "request"
request set_address(service_name string, object_path string)
        | Must be a valid identifier
request set_address(service_name string, object_path string)
                    | One unit with two parts: identifier and type
request set_address(service_name string, object_path string)
                   ^                                       ^
                   |                                       |
                   | these surround our arguments          |
request set_address(service_name string, object_path string)
          this separates our arguments |

Describing this will roughly look like this:

"request" @Ident "(" argument, argument ")"

Let's put that into a struct:

type Request struct {
    Name      string     `"request" @Ident "("`
    Arguments []Argument `{ @@ [","] } ")"`

{ @@ [","] } is a fancy way of making the Arguments field say “capture as many of me as possible, and we might have a comma separating us.”

Now let's write an Argument struct.

type Argument struct {
    Name string `@Ident`
    Type string `@Ident`

Since this is basically just a tuple of identifiers, that's exactly what we made this struct.

Because an interface can have multiple requests, we add the following field to our Interface struct: Requests []Request `{ @@ } Like above, { @@ } will try and capture as many Requests as possible.

Put together, all our structs look like this:

type Interface struct {
    Name     string       `"interface" @Ident "{"`
    Requests []Request    `{ @@ }`
    Ending   struct{}     `"}"`
type Protocol struct {
    Name string `"protocol" @Ident`
type Request struct {
    Name      string     `"request" @Ident "("`
    Arguments []Argument `{ @@ [","] } ")"`
type Argument struct {
    Name string `@Ident`
    Type string `@Ident`

Three: parsing trees

Now that we have our AST designed, let's hook it up to Particple.

parser := participle.MustBuild(&ProtocolDescription{})
protocol := Protocol{}
parser.Parse(os.Stdin, &protocol)

That's easy, eh? Since building XML output is fairly straightforward (just build structs corresponding to the XML output and marshal the AST into them and marshal the structs into XML), I won't be covering that here.

From Here

Some links you may find useful:

blankInterface: A more complete Wayland protocol parser and XML generator.

Participle: The parser library used.

encoding/xml: XML library in Go's stdlib.

Tags: #libre

Hi there! I’m very excited to share that my proposal to work on improving MMS support to the KDE-Connect’s SMS app has been accepted into GSoC 2020. I’m very excited to work on this project. The official coding will begin 1st June and will end on 24th august. To know more about GSoC and KDE click on the given below links.

GSoC is an open-source program hosted by google in which accpted students from all over the world works on an open source project with the assigned mentor for three months. GSoC


KDE is an open-source organization developing user friendly desktops environments for linux and huundreds of differnt softwares. KDE



6 May, 2020

So I have an NVIDIA SHIELD K1 Tablet that used to be quite popular as a gaming tablet around 2014-2015. It’s a pretty nice tablet. There are no powerful AND economically priced android tablets in the market anymore, as far as I could find. But who am I kidding, I bought this tablet because I was on a shopping spree last year after I officially wrapped up my Google Summer of Code 2019 project. I should probably make an expense report for the stipends I earned from the program as it was my first ever income! This weekend I came to know of Linux4Tegra,  a GNU/Linux based system software distribution by Nvidia for the Nvidia Tegra processor series. (you can read more about it at Wikipedia). So I checked out the releases by NVIDIA here and found out there was something available for my shiny K1 too! I sniffed around in xda forums and found out a forum post by Bogdacutu

Last weekend I stumbled upon Linux4Tegra while looking for custom ROMs to breathe new life into this 2015 device. I got up to Ubuntu 18.04, so this is what my final sequence of steps was. to make sure you can also have a working Desktop Ubuntu tablet within a day:-

  1. I have hosted the files for download here:
  2. Forum post for Linux4Tegra for NVIDIA SHIELD TABLET K1:
  3. NVIDIA SHIELD TABLET K1 stock firmware:
    get the version 0.0.0 Factory Image ^
  1. Make sure USB Debugging is turned ON. Boot into the bootloader.
    adb reboot bootloader
  2. Flash stock firmware that has Android Lollipop (absolute requirement for Linux4Tegra to boot up. L4T doesn’t boot up on newer bootloaders).
    Just run the bundled as root and it will handle everything automatically.
  3. Reboot the device to make sure android lollipop is fine.
    1. Feel free to set up the Tablet’s android at this step. You will always be able to switch back and forth between android and L4T (dual-boot tablet; cool, right? ✨).
      Once you are done with setting up your android, make sure USB Debugging is enabled and continue to next step.
  4. Flash twrp-multirom-20150909-UNOFFICIAL-shieldtablet.img to recovery.
    adb reboot bootloader
    fastboot flash recovery twrp-multirom-20150909-UNOFFICIAL-shieldtablet.img
  5. Boot into recovery. Bootloader will have the third option to boot into recovery mode. Feel free to use that.
  6. Flash from within TWRP Recovery. This is super important – L4T boot will always fall back to lollipop without this. You do not need a micro SD Card – there is MTP support in TWRP Recovery.
    As a side note, feel free to use adb sideload to sideload the zips from your desktop. (save yourself from house-keeping later)
  7. Reboot into recovery. There’s option for that in Reboot menu in TWRP Recovery.
  8. Flash from within TWRP Recovery. This will add multiROM support to your tablet’s bootloader.
  9. Reboot into recovery mode again. Feel free to boot into android once to make sure all’s OK.
  10. Flash from within TWRP recovery. This will fix the touch support for multiROM boot menu.
  11. Reboot into recovery (this is the last one).
  12. Go to Advanced Menu, click on Add ROM, and flash Linux4TegraR231.mrom. This will install Linux4Tegra in your internal storage (by default; you can also use an external storage such as SD Card or USB storage to install L4T, it works). The ROM lives in /storage/emulated/0/roms/
  13. Reboot to system.
  14. Boot to Linux4Tegra231 from the boot menu. 😀

Welcome to Ubuntu 14.04 !

Well, pat yourself on the back, you have gone through a lot of risk already. It’s about to get bumpy from here.

Stuff that doesn’t work: 3G/LTE, accelerometer, GPS, camera
Stuff that does work: GPU (full OpenGL 4.5 and Vulkan), sound, USB device and host, WiFi, Bluetooth, touchscreen, sound, SD/USB install, HDMI playback

You might need a keyboard at first install; you might need holding on the key to record the input. This happens just during the first set-up, everything is fine once the set-up is done.

if(camp.set() == true)

You will have to hold xserver-xorg-core package to make sure the display keeps working. Do that with the following command:-

sudo apt-mark hold xserver-xorg-core

Onwards to another release upgrade!

Perform the following commands to upgrade your release from 16.04 to 18.04. You will have to unhold xserver-xorg-core now in order to step ahead to the next release. Run these commands now:-

sudo apt-mark unhold xserver-xorg-core
sudo apt update && sudo apt upgrade -y

Once the system reboots, run this command:-

sudo do-release-upgrade

Make sure you don’t rewrite any files that were edited after installation. The installation procedure might ask you for multiple files that were edited after installation. Until you’re absolutely sure that you should allow rewriting a particular file, I recommend not to let the installation touch any of those files. It shows up multiple times, make sure not to overwrite them.

Welcome to Ubuntu 16.04 !

Stuff that doesn’t work: touchscreen, past issues from 14.04

Fix Touch Support

Make the file /usr/share/X11/xorg.conf.d/10-evdev.conf, make the last section look like this:

Section "InputClass"
Identifier "evdev touchscreen catchall"
MatchIsTouchscreen "on"
MatchDevicePath "/dev/input/event*"
Driver "evdev"
Option "InvertX" "yes"
Option "InvertY" "yes"
Option "Calibration" "0 1199 0 1919"

2. Run rm-wrapper on your tablet. Be sure to run this command in a root shell after doing the exports. You need this to make sure touch keeps running. If you would be fine without touch support, feel free to go ahead to 18.04. If you can improve touch support for 18.04, I’d love to sign up as a tester! Add these lines to /etc/rc.local to automate this. These lines expect that rm-wrapper has been renamed to .rm-wrapper (so it stays hidden from regular view when you use the tablet). Be sure to rename PUT_YOUR_USERNAME_HERE to your user name.

export LD_LIBRARY_PATH=/system/vendor/lib/hw:/system/vendor/lib:/system/lib
export TOUCH_CONF_DIR=/mnt/factory/touchscreen
export TOUCH_DATA_DIR=/data/misc/touchscreen
/home/PUT_YOUR_USERNAME_HERE/.rm-wrapper /dev/null &

Onwards to another release upgrade!

This time the upgrade process is simple enough. Run these commands now:-

sudo apt update && sudo apt upgrade -y

Once the system reboots, run this command:-

sudo do-release-upgrade

As the last time, make sure you don’t rewrite any files that were edited after installation.

Welcome to Ubuntu 18.04

Stuff that doesn’t work: DNS resolution, past issues from 16.04
CAUTION: The rm-wrapper fix does not work with Ubuntu 18.04. Fixes are welcome! (source link)

To Fix DNS Resolution

Add this line to the end of /etc/rc.local to fix your internet

echo "nameserver" | tee -a /etc/resolv.conf

But this is a poor hack – if resolvconf service ever restarts, your internet will go bonkers again, so you could either run that command (as root) yourself later again, or just restart the tablet. I tried working with netplan to fix it but that apparently crashed the whole WiFi during boot-up! xD


So I realized soon enough that universe repositories were disabled upon installation in this particular case. Not to worry, a simple command enables universe support for us:-
sudo add-apt-repository universe

mandatory screenfetch shot 😅

But can it run Plasma?

Using tasksel we can quickly install Plasma desktop on top of ubuntu.
sudo tasksel install kubuntu-desktop

Once that was done, I logged out of my current Desktop Environment which comes with Ubuntu 18.04, and logged into Plasma. The experience was beyond amazing!

Plasma Gallery

If I were to be honest, I don’t really know what I would do with the linux on my tablet. If I will use this tablet as any forms of a daily driver, I will probably set up an Arch VM on of top the Ubuntu 14.04 and use the Arch installation from within Ubuntu. I don’t know how/ if it will work out as a practically viable option, but that’s probably what I’ll try out next week! For now, I am just content with the fact that I have a convertible android tablet that doubles as an SoC computer with display! 😄 I’m really glad with how it turned out, since I already plan to operate with this tablet remotely (SSH or VNC) when I have to do anything. 😋

It would be amazing if developers from the XDA Developers community hop back on this project! Well, not just because I own one of these tablets xD. I think there was more than enough hardware in this tablet for its time, and no hardware is underpowered to run Linux on it. In my defense, well this has been achieved once by NVIDIA, and then once rejuvenated by Bogdacutu, I think it’s only about time someone else gives it a shot? 😃

Hello Planet!

Amyspark posted at 00:00 amyspark

Hi everyone! It’s been so long since I started this site, back in July 2017. It’s been mostly to showcase my open source work and have a place for potential business contacts, and I’ve never ever blogged a bit because long prose is kind of difficult for me. (Also, I’m very fearful of our dear internet trolls.)

Today, I’m finally getting out of my shell. I’ve been selected as a participant for Google Summer of Code 2020, working with KDE on the Krita painting suite.

Looking back on my logs, it was in October 2016 (shortly before my graduation) that its maintainer, Boudewijn Rempt, and Pepper & Carrot’s author, David Revoy, welcomed me with open arms to the FOSS world. In the four years that passed, I’ve learnt a lot: graduated, started my MSc, almost finished it, and landed my first job in the industry. I can’t express how deeply thankful I am for their help and advice, so the only way I could think of returning the favor was to tackle a Big Thing in Krita.

The project I will be working on is called, “Dynamic Fill Layers in Krita using SeExpr”, and I’ll be mentored by Boudewijn, Dmitry Kazakov, and Iván Yossi.

Here’s the listing page, its Phabricator task and the full proposal (Google Docs link). A Portfolio entry will be up in due notice.

To summarize, Krita already has support for various types of Fill Layers, but unlike other open source toolkits (Blender for instance), it does not have a direct way to script or otherwise author custom textures or patterns. Disney Animation has been working on a library for this purpose, called SeExpr. In their own words,

SeExpr is an embeddable, arithmetic expression language that enables flexible artistic control and customization in creating computer graphics images. Example uses include procedural geometry synthesis, image synthesis, simulation control, crowd animation, and geometry deformation.

Walt Disney Animation Studios, SeExpr.

The objective of the project is to let artists create dynamic content through a new, scriptable Fill Layer through the SeExpr expression language.

I’ll be around on IRC (amyspark at #krita or, occassionally, #pepper&carrot), and I hope we’ll be reading each other soon!



Hello students,

I no longer have access to your proposal or emails, thus the open letter on my blog.

If you allowed commenting before the student proposal deadline, I along with other admins and mentors tried to help you improve your proposal. Some of you took the suggestions and sharpened your presentation, fleshed out your timeline and in general created a proposal you can be proud of.

If you did not allow commenting or only uploaded your proposal right before the deadline, you missed out on this mentoring opportunity, and for that I am sorry. That cut us off from a vital communication link with you.

This proposal process, along with fixing some bugs and creating some commits mean that you have real experience you can take with you into the future
. I hope you also learned how to use IRC/Matrix/Telegram channels to get information, and help others as well. Even if you do not continue your involvement with the KDE Community, we hope you will profit from these accomplishments, as we have.

We hope that your experiences with the KDE community up to now make you want to continue to work with us, and become part of the community. Many students whom we were not able to accept previously were successfully accepted later. Some of those students now are mentoring and/or part of the administration team, which is, in our eyes, the zenith of GSoC success.

Some of you we were unable to accept because we could not find suitable mentors. The GSoC team is asking us this year to have three mentors per student, because the world has become so uncertain in this pandemic time. So more developers who will mentor are a precious resource.

Almost every single proposal we got this year is work we want and need, or we wouldn't have published "Ideas" to trigger those proposals. If you are interested in doing this work and do not need the funding and deadlines that GSoC provides, we would welcome working with you outside of GSoC. In fact, each year we have Season of KDE which provides some mentoring, structure and timeline and no funding. This has been very successful for most mentees. And of course all are welcome to join our worldwide army of volunteers, who code, fix bugs, triage bug reports, write, analyze, plan, administer, create graphics, art, promo copy, events, videos, tutorials, documentation, translation, internationalization, and more! It is the KDE community who makes the software, keeps it up-to-date, plans and hosts events, and engages in events planned and hosted by others.

Please join the KDE-Community mail list and dig in! Hope to see you at KDE Akademy.