Kimonote User Guide

Introduction

Kimonote is a text-first minimalist blogging platform and note organizer that focuses on ease of navigation and control over content that a user follows.

This is a rough outline of Kimonote features and how to use them. If you prefer a more interactive guide, why not try the Kimonote demo?

If there's anything left unclear after reading this guide or anything you wish to see added, please contact support@kimonote.com!

Creating and editing notes

Go to kimonote.com/new to create a new note. You can use Markdown to write notes. Images are supported, but only if they're hosted externally for now.

Tags are supported and encouraged. Kimonote can also suggest tags based on the contents of the note using natural language processing. To get a suggestion, simply edit the note after it's been written.

In the edit view, you can also set whether a note is public or not.

Finally, you can also attach a link to the note, allowing for bookmarking.

Bookmarklets

The note creation view supports link, title and text query parameters, setting its initial values. This allows for bookmarklets that let you quickly bookmark some text or a note in Kimonote. For example:

javascript:(function(){open('https://www.kimonote.com/new?link='+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)+'&text='+encodeURIComponent(window.getSelection().toString()).replace(/#/g, '%23'),'targetname','height=500,width=300');})()

This bookmarklet will show the Kimonote note creation view, prepopulated with the currently selected text and a link to the page you're currently viewing.

Alternatively, copy this link to install the bookmarklet.

MathJax

Kimonote focuses on minimal page sizes and so uses almost no JavaScript. One exception is MathJax, which allows to typeset mathematical formulas using LaTeX. You'll need to escape some of Tex's control characters in order to be able to use them in Markdown.

For example:

\\[ \\frac{a\_1}{b\_1} \\]

becomes \[ \frac{a_1}{b_1} \]

To get MathJax to load in your note, tick "MathJax" in the edit view.

Tag-based navigation

User's notes that have the same tag are linked together in the note view, meaning that you will never need to set up links between posts from the same series again. For example, if you have three notes:

• A is tagged a, b, c
• B is tagged b
• C is not tagged at all
• D is tagged a, b

Then Kimonote will automatically generate links:

• from A: to B (since they're both tagged b) and D (since they're both tagged a);
• from B: to A and C (since it's the next post in the blog);
• from C: to B and D (since they're the previous and the next post);
• from D: to A (since both are tagged a), B (since both are tagged b) and C (since it's the previous post).

Streams

Streams are collections of notes from certain users with certain tags that can help you organize your content or follow just specific notes from a user. A stream view can be accessed at:

https://kimonote.com/@user1:tag1,tag2,tag3,@user2,@user3:tag2,tag3

This means you'll see, in that view, all public posts from user1 tagged tag1, tag2, tag3; all posts from user2 and all posts from user3 tagged tag2 and tag3. If you are included in the stream (and are logged in), you'll see your private posts too.

You can change the current stream view by clicking on "(show contents)" on the sidebar or just appending ?edit=1 to the URL. This gives you a visual interface that lets you inspect what the stream contains or change its contents.

You can also search through all notes in a given stream, change the view between compact and full, as well as show notes ordering them by post time ascending or descending (useful for reading some long-form series).

Finally, there's an RSS feed available for every stream containing its public notes: click the link on the sidebar or append /rss/ to the URL.

Named streams

You can save a stream you're viewing: this allows you to, for example, see when it's been updated. Streams you have saved are available at the top in "(my streams)".

To save a stream, click on "Save as new / existing" in the contents menu on the sidebar. Here, you can either name a new stream or select a stream to overwrite or merge the current view with.

A saved stream's contents show by default. If you wish to edit them, you will be redirected to a temporary stream view and after you're done editing, you can overwrite the saved stream with the new contents.

Default streams

You can have one default stream. When you're viewing any other unnamed stream (such as all posts from a user with a given tag), you can add its contents to this stream directly: just click "Follow in..." in the sidebar. The default stream can be changed by opening a stream and clicking "(set as default)" in the sidebar.

Exporters

Stream exporters push new notes in a given stream to a specified destination. Currenly, only e-mail is supported, but in the future, the ability to push contents to Facebook/Twitter or other social media platforms will be available. The e-mail exporter allows you to get a digest of all new items in a given stream.

To view all exporters for a stream, go to the stream view and click on "Manage subscriptions...", and to view all of your exporters, go to "(manage)" in the top right corner and then on "Exporters".

For an e-mail exporter, you can specify the target e-mail (which must be one of your verified e-mail addresses) as well as a schedule (every 5 minutes, hourly or daily at a given hour).

When you create your account and verify your e-mail, you get a default stream called "My subscriptions" created for you, containing all posts by @kimonote. It's linked to an exporter that notifies you when Kimonote publishes a new post. If you don't wish to be notified, you can either delete the exporter or delete the stream.

Importers

Kimonote can act as an RSS feed reader with its importer function: you can set it up to poll a given RSS feed and convert its contents into your own private notes with some tags. To filter whether you wish to see notes written by yourself or imported from a different source, you can choose between internal or external sources in the note overview.

Your current importers can be managed in the Manage screen on the right side of the navigation bar.

Together with the e-mail exporter function, you can create your own newsletters and receive digests from RSS feeds at any frequency. One way of doing it would be creating a stream that follows yourself and add an e-mail exporter to it, configuring it to only send notes imported externally. Alternatively, you can set up your importers to assign different tags to your notes and subscribe to them at various frequencies.

API

Kimonote has a basic REST API to list notes in a stream as well as create/read/update/delete notes.

Firstly, you can append json/ to any stream URL to get a JSON-formatted list of notes like this. Only the first 15 notes are returned. To get to the next page, append ?from=(id of the last note in the result), for example, like this. You'll only see your public notes if you're not authenticated.

Authentication happens by submitting a POST request with your username and password to https://kimonote.com/api/login/. In exchange, you will get an API token which you should submit with all of your requests as a header: Authorization: Token (your token).

Secondly, https://kimonote.com/api/notes/ contains an API that allows you to programmatically create, update and delete your own notes. This API works only when you're authenticated. It's easier to showcase what the API can do with a bit of Python code, using the Requests library:

import requests

ROOT = 'https://kimonote.com/'
API_ROOT = ROOT + 'api/'
USERNAME = # your username here
PASSWORD = # your password here

# Obtain the token
token = requests.post(API_ROOT + 'login/', json={'username': USERNAME, 'password': PASSWORD}).json()['token']
HEADER = {'Authorization': 'Token %s' % token}

# An OPTIONS request shows the format the API expects a note to be in, as well as the calls it supports
print(requests.options(API_ROOT + 'notes/', headers=HEADER).json())

# Let's create a new note by making a POST request to the API endpoint
new_note = {'title': "Test note",
            'is_public': True,
            'has_mathjax': False,
            'text': "Test note",
            'tags': ['test', 'note'],
            'link': 'http://google.com'}
new_note_id = requests.post(API_ROOT + 'notes/', json=new_note, headers=HEADER).json()['id']

# Now let's update the note's title using a PATCH request
requests.patch(API_ROOT + 'notes/%d/' % new_note_id, json={'title': 'Test note: updated'}, headers=HEADER)
note = requests.get(API_ROOT + 'notes/%d/' % new_note_id, headers=HEADER).json()
assert note['title'] == 'Test note: updated'

# Now copy someone else's note
new_note_2 = requests.get(ROOT + '@kimonote/json/', headers=HEADER).json()[0]
new_note_2_id = requests.post(API_ROOT + 'notes/', json=new_note_2, headers=HEADER).json()['id']
note = requests.get(API_ROOT + 'notes/%d/' % new_note_2_id, headers=HEADER).json()
assert note['text'] == new_note_2['text']

# Finally, delete the two notes we created.
requests.delete(API_ROOT + 'notes/%d/' % new_note_id, headers=HEADER)
requests.delete(API_ROOT + 'notes/%d/' % new_note_2_id, headers=HEADER)