libremarkable

> I rather mean the firmware of the e-ink driver board, which is a trade secret. I don't know, maybe it is not even firmware in an MCU, but they have a dedicated driver chip and it just has the look-up-tables. Anyway, the secret sauce that tells you how to drive the display cells. Huh? What e-ink driver board? There's no such thing inside a Kindle. It is a straight NXP SoC that drives the e-ink panel directly. There is no MCU. The driver is open source. https://github.com/canselcik/libremarkable/blob/master/refer... "Secret sauce that tells you how to drive the display cells"? You mean like a voltage table that is also present inside every LCD or OLED? The difference would be that the electrophoretic display would need a much bigger table so it would have to be kept on the SoC since it can't possibly fit into a single voltage driver circu

Can this work on the Remarkable Tablet? And other EInk Screens? I'm not sure how exactly I can get this to compile for an armV7 Architecture. I believe the only way to build apps for Remarkable is using QT: https://github.com/canselcik/libremarkable

I use the Remarkable. I love it for marking up documents and writing brief notes/sketches. Also (you may already know this if you've researched it) it exposes ssh and you can get root, so you can pretty much put any program you want on it. I've used https://github.com/canselcik/libremarkable to write some basic apps for it. One thing I'll note is that the hand-writing -> text converter never really worked that well for me. I have messy handwriting so YMMV. I would still recommend it, but if that's the killer feature for you it's something to keep in mind

For the original one at least, yes. The official stuff is at https://remarkable.engineering/ and there are a few Rust projects built around libremarkable https://github.com/canselcik/libremarkable

I am actually wondering to see I buy one. Here is some links that I find interesting to consider before buying (some of those do answer some previous comments) : * Here is a [previous occurrence on HN](https://news.ycombinator.com/item?id=16321531). * Here is a ["curated list of (code) projects related to the reMarkable tablet"](https://github.com/reHackable/awesome-reMarkable). * Here is a [framework](https://github.com/canselcik/libremarkable) for "developing applications with native refresh support for Remarkable Tablet " (with a growing Rust APi if you fancy that). Some notes : * As you will see by exploring some the links, the tablet is Linux-based so it is definitely possible to piggy-back on some API (see https://github.com/reHackable/awesome-reMarkable#apis for examples) * A bunch of alternative synchronization tools have already

Remarkable Tablet is an awesome device with a great, open ecosystem. I was able to "reverse" the API by tracing the ioctl calls made by xochitl (their main application on the device) and analyzing it with IDA + Ghidra. They also provide the source to their kernel modifications to clarify a few things. It is also noteworthy that they are very friendly to open source development as shown by their CTO coming in and answering an issue created on the libremarkable repo. :) Here is something I did in Rust: https://github.com/canselcik/libremarkable Findings regarding the hardware/software stack: https://github.com/canselcik/libremarkable/wiki/Framebuffer-... And here is a fork of plato e-reader that uses libremarkable to run on Remarkable: https://github.com/darvin/plato Color palette demo: https://camo.githubusercontent.com/dfe0fa57b14dd8f2c45

Yeah, his series is really great and it made me realize the FW flashed on these CARTA panels are actually nothing but the raw waveforms themselves. One thing that I want to note is that while their documentation might be closely guarded secret, the actual waveforms are actually available out in the open. For instance here are the raw waveforms for one of the latest Carta generation e-paper panel: https://github.com/canselcik/libremarkable/blob/master/refer... ~ hexdump -C epdc_ES103CS1.fw | head -10 00000000 34 88 c4 7c 01 2d 01 00 dd 09 00 00 07 06 a4 00 |4..|.-..........| 00000010 03 58 21 1d 3c ca 01 85 02 00 00 00 40 00 00 fe |.X!.<.......@...| 00000020 47 00 00 01 00 04 0d 00 ff fc 00 00 00 00 00 54 |G..............T| 00000030 00 03 06 09 0c 0f 12 15 18 1b 1e 21 26 2b 30 28 |...........!&+0(| 00000040 00 00 0

You can literally SSH into it, the password is in the GPLv3 license text. I just mount the data directory via sshfs and run the unofficial Linux app: #!/bin/bash fusermount -u ~/.var/app/com.remarkable.desktop/data/remarkable/desktop sshfs -o nonempty root@rmk:.local/share/remarkable/xochitl ~/.var/app/com.remarkable.desktop/data/remarkable/desktop flatpak run --filesystem=~/myBooks/ com.remarkable.desktop read -p "Restart xochitl? " -n 1 -r if [[ $REPLY =~ ^[Yy]$ ]] then ssh root@rmk systemctl restart xochitl fi fusermount -u ~/.var/app/com.remarkable.desktop/data/remarkable/desktop There's a wiki: http://remarkablewiki.com/ A subreddit: https://www.reddit.com/r/RemarkableTablet/ Toolchain: https://remarkable.engineering Unofficial ePaper library: https://github.com/canselcik/libremarkable flatpak package for t

This looks really nice. I have been working on something that might perhaps be of interest to you. https://github.com/canselcik/libremarkable I would love it if someone built a terminal emulator using it. All the pieces needed to achieve that is already in place.

Oh yes definitely, it comes with root-access by default (and Vim preinstalled!). And there are interesting open-source libraries available to hack in new features: https://github.com/canselcik/libremarkable

The tools exist with which to do it. People have reverse-engineered the reMarkable enough to start creating Rust libraries to support the hardware[1]. I've been thinking of experimenting with building a Sketchpad-like system on it. With Rust, you have access to LLVM fairly easily, so you could probably do something with JIT compiling code (maybe a Smalltalk dialect) to give whatever you build a programmable interface. Why Smalltalk? It's simple syntax would be easier to deal with on the reMarkable, and you might be able to look at doing handwriting recognition to let you write the code with the stylus. Could also go with a Lisp, for similar reasons. All of this is just speculation because I haven't started it for lack of time, but I'm really interested in exploring what's possible in that space. The system specs will probably be constrain

Thanks. It is the Remarkable Tablet but the API is entirely undocumented. Took a fair bit of analysis to get it to this state but now it is actually ready for people to build their own applications upon it. The GitHub project: https://www.github.com/canselcik/libremarkable