Xournal++ vs Rnote on Linux Mint: Two Note-Taking Apps, Two Very Different Workflows

If you are using Linux Mint and looking for a good handwriting or note-taking application, you will quickly come across two interesting open-source options:
Xournal++ and Rnote.

At first glance, they look quite similar.

Both let you write with a stylus, draw on a digital canvas, erase things, add text, and organize your notes. If you have a drawing tablet such as a Wacom, both can turn your Linux desktop into something that feels surprisingly close to writing on paper.

But after using both, I don't think the best way to look at them is:

"Which one is better?"

A more useful question is:

"What am I trying to do?"

For me, the answer is quite different depending on the situation.

Xournal++ feels like a digital notebook.

Rnote feels more like a digital whiteboard.

And that difference makes them useful for completely different workflows.

Why use handwriting apps on a computer in the first place?

Before getting into the applications, you might be wondering:

Why not just use a normal text editor?

As a software engineer, I spend a lot of time typing. For documentation, programming, emails, configuration files, and normal notes, a keyboard is obviously faster.

But there are some things that are simply easier to explain or understand by drawing.

Think about:

• solving a math problem
• working through an algebra equation
• drawing a flowchart
• sketching a software architecture
• explaining an algorithm
• drawing a network diagram
• quickly annotating a PDF
• making a rough UI idea
• explaining something to another person

When you need to put these thoughts down quickly, handwriting can actually be more natural than typing.

And this is where a cheap drawing tablet becomes surprisingly useful.

Turning a Wacom tablet into a digital notebook

You don't necessarily need an expensive pen display.

A simple pen tablet such as:

• Wacom Intuos Medium CTL-6100WL
• Wacom One by Wacom CTL-472

can work as a digital pen.

You look at your monitor while moving the pen on the tablet, and your handwriting appears on the screen.

At first, this feels slightly strange.

You are writing on one surface while looking at another.

But once you get used to it, the combination of Linux Mint + Wacom + Xournal++/Rnote becomes a very interesting paper replacement.

And there is one major advantage:

You don't run out of pages.

Xournal++: My Digital Notebook

If I had to describe Xournal++ in one sentence, I would say:

Xournal++ is what I would reach for when I want to replace a physical notebook.

It is particularly interesting when your notes involve handwriting, PDFs, diagrams, equations, and annotations.

1. Practising mathematics without using paper

This is probably one of the most obvious use cases.

Imagine that you are preparing for an aptitude test or simply trying to improve your mathematics.

Normally, you might have:

Question → notebook → pen → solve → erase → solve again

With Xournal++, the workflow becomes:

Question → Xournal++ → Wacom tablet → solve

You can write equations naturally, cross things out, draw arrows, circle important numbers, and work through the problem exactly as you would on paper.

For example, you could practise:

• Algebra
• Linear equations
• Quadratic equations
• Percentages
• Ratios
• Probability
• Number systems
• Logical reasoning
• Aptitude questions
• Calculus
• Geometry

The interesting part is that you are not trying to turn mathematics into a typed document.

You are simply recreating the scratch-paper experience digitally.

2. Solving programming problems by hand

This is where it becomes particularly useful for a software engineer.

Before writing code, sometimes I want to think about the problem away from the editor.

For example, suppose I am trying to understand a recursive algorithm.

Instead of immediately opening VS Code and writing code, I can sketch:

solve(5)
   |
   +---- solve(4)
   |       |
   |       +---- solve(3)
   |
   +---- ...

I can draw arrows, write intermediate values, cross out mistakes and experiment with different approaches.

This can be especially useful for:

• recursion
• dynamic programming
• sorting algorithms
• graph algorithms
• tree traversal
• memory layouts
• state machines
• algorithm complexity
• debugging logic

Sometimes the fastest way to understand a programming problem isn't to type more code.

It's to draw the problem first.

3. Digital scratch paper while programming

Here's another simple use case.

Imagine you're debugging something complicated.

You have:

API
 ↓
Controller
 ↓
Service
 ↓
Repository
 ↓
Database

But somewhere in that chain something isn't behaving as expected.

Rather than opening another text file and writing a perfectly formatted document, you can simply draw the architecture and start making notes.

For example:

"Request reaches here."

"Why is this value null?"

"Check this function."

"Maybe race condition?"

That's exactly what a physical piece of paper is good at.

Xournal++ gives you that scratch space without the physical paper.

4. Annotating PDFs

This is another area where Xournal++ becomes extremely useful.

Suppose you're reading:

• programming documentation
• a textbook
• research papers
• lecture notes
• technical documentation
• exam material

Instead of just reading the PDF, you can write directly on it.

Circle something.

Underline something.

Add an explanation.

Draw an arrow.

Write a question in the margin.

It starts feeling much more like studying from a physical book.

5. Learning something difficult

I also think handwriting is particularly useful when learning.

For example, imagine learning a new computer science concept.

You could create a page containing:

Binary Search Tree
        50
       /  \
     30    70
    / \    / \
   20 40  60 80

Then annotate it:

• insertion
• deletion
• traversal
• complexity
• edge cases

The page doesn't need to be beautiful.

It only needs to help your brain understand the concept.

That's one of the biggest advantages of handwriting.

6. Brainstorming software ideas

Not every idea starts as a polished architecture diagram.

Sometimes it starts as:

     App
      |
   ┌──┴──┐
   ?     ?
  API   DB
   |
   ???

You can scribble ideas, move around the page and connect things.

That makes Xournal++ useful as a software-engineering scratchpad.

You could have separate notebooks/pages for:

• Project ideas
• Architecture
• Database design
• Algorithms
• Interview preparation
• Learning notes
• Debugging sessions
• Meeting notes

Rnote: When the Notebook Becomes a Whiteboard

Now we get to Rnote.

My mental model for Rnote is quite different.

If Xournal++ feels like:

"My digital notebook"

Rnote feels more like:

"A whiteboard sitting on my desktop."

And that makes it particularly interesting for explaining things.

1. Explaining concepts visually

Imagine you're trying to explain how an HTTP request works.

You could simply type:

The client sends an HTTP request to the server, which processes the request and returns a response.

Or...

You could draw:

┌──────────┐       HTTP Request       ┌──────────┐
│  Client  │ ───────────────────────> │  Server  │
│          │ <─────────────────────── │          │
└──────────┘       HTTP Response      └──────────┘

And then talk through it.

The second approach can be much easier to understand.

This is where Rnote becomes interesting.

2. Use Rnote + OBS Studio for YouTube videos

This is probably my favourite Rnote use case.

You can combine:

Rnote + Wacom + OBS Studio + microphone

to create a very simple educational video setup.

For example, imagine you want to make a YouTube video:

"How recursion works"

Instead of preparing dozens of slides, you open Rnote and start drawing.

factorial(4)

    ↓

4 × factorial(3)

    ↓

4 × 3 × factorial(2)

    ↓

4 × 3 × 2 × factorial(1)

    ↓

24

While OBS records your screen, you explain the concept using your Wacom tablet.

You can pause.

Erase something.

Draw another arrow.

Go back.

Add another example.

It feels much more like a teacher standing at a whiteboard.

And you don't need a complicated video-production setup.

3. Explain programming concepts

This workflow can work extremely well for software-engineering content.

For example:

"How a HashMap works"

You could draw:

        key
         ↓
      hash()
         ↓
   ┌───────────┐
   │  Bucket 3 │
   └─────┬─────┘
         ↓
      value

Then gradually build the explanation.

Or:

"How Git works"

Draw:

Working Tree
     ↓
   git add
     ↓
Staging Area
     ↓
  git commit
     ↓
 Repository

Or:

"How Docker containers work"

Draw:

Application
     ↓
 Container
     ↓
 Docker Engine
     ↓
    Linux
     ↓
   Kernel

The visual explanation becomes the video.

4. System architecture sketches

As a software engineer, this is another area where I think Rnote can shine.

Suppose you're designing a system:

             ┌────────────┐
             │   Client   │
             └─────┬──────┘
                   ↓
             ┌────────────┐
             │ API Server │
             └─────┬──────┘
                   ↓
        ┌──────────┴──────────┐
        ↓                     ↓
   ┌─────────┐          ┌──────────┐
   │  Cache  │          │ Database │
   └─────────┘          └──────────┘

You can sketch the architecture while explaining your thinking.

This is useful not only for YouTube videos but also for:

• team discussions
• technical interviews
• design brainstorming
• architecture planning
• explaining bugs
• teaching junior developers

5. Recording yourself solving a problem

Another interesting workflow is to turn Rnote into a digital problem-solving whiteboard.

For example:

"Let's solve this algorithm problem together."

Open Rnote.

Start OBS.

Read the problem.

Then think aloud while drawing.

You don't need perfectly prepared slides.

The imperfections can actually make the explanation feel more natural.

Xournal++ vs Rnote: How I Think About Them

Rather than comparing dozens of features, I would use a simple rule:

Situation	App I'd choose
Practising mathematics	Xournal++
Aptitude preparation	Xournal++
Annotating PDFs	Xournal++
Personal handwritten notes	Xournal++
Programming scratch work	Xournal++
Studying technical material	Xournal++
Brainstorming	Either
Explaining a concept visually	Rnote
Whiteboard-style teaching	Rnote
Recording tutorials	Rnote
YouTube educational videos	Rnote
Architecture sketches	Rnote
Drawing while explaining	Rnote

Of course, there is overlap.

You can use either application for many of these tasks.

The point isn't that one application cannot do something.

It's that each one encourages a slightly different workflow.

My Linux Workflow

If I were setting up a Linux Mint machine specifically for these kinds of activities, my setup would be something like:

Linux Mint
↓
Wacom tablet
↓
Xournal++ → studying, mathematics, notes, PDFs, problem solving
Rnote → whiteboarding, explaining, teaching, recording
↓
OBS Studio → recording the screen
↓
YouTube → publishing tutorials

And suddenly a Linux desktop becomes more than just a programming environment.

It becomes a small digital classroom.

The Paper Replacement Experiment

One of the most interesting things about this setup is that you don't have to completely abandon paper on day one.

Try a small experiment.

Take one activity that you normally do on paper.

For example:

Solving 20 aptitude questions.

Instead of taking a notebook, open Xournal++.

Connect your Wacom tablet.

Create a page.

Start solving.

After a week, ask yourself:

• Was writing comfortable?
• Was the tablet responsive enough?
• Did I make fewer or more mistakes?
• Was it easier to keep everything organized?
• Did I actually enjoy the workflow?
• Did I miss physical paper?

You might discover that some tasks are actually better digitally.

And for others, you may still prefer paper.

That's perfectly fine.

The goal isn't to replace paper because paper is bad.

The goal is to find situations where digital handwriting is simply more convenient.

You Don't Need to Be an Artist

This is probably the most important thing for beginners.

You don't need beautiful handwriting.

You don't need artistic skills.

You don't need an expensive Wacom display.

You don't need a huge monitor.

And you certainly don't need to create perfect diagrams.

A rough circle with an arrow pointing to a box can sometimes explain a software concept better than a perfectly formatted diagram.

The important thing is:

Don't think of Xournal++ and Rnote as drawing applications.

Think of them as thinking tools.

Your keyboard is great when you know exactly what you want to say.

Your pen is great when you're still figuring out what you think.

Final Thoughts

For me, Xournal++ and Rnote aren't really competitors.

They solve two different problems.

Xournal++ is the digital notebook I would use when I want to work something out.

• Math problems.
• Programming problems.
• PDF annotations.
• Study notes.
• Algorithms.
• Random ideas.
• Debugging.
• Scratch work.

Rnote is the digital whiteboard I would use when I want to explain something.

• Draw it.
• Talk about it.
• Record it.
• Share it.
• Teach it.

And when you combine either one with a simple Wacom tablet, Linux Mint becomes surprisingly capable as a handwriting and teaching environment.

You may start by thinking:

"I just want to replace my notebook."

And eventually find yourself thinking:

"Wait... I can use this to teach on YouTube too."

That's where this setup gets really interesting.