Kube: new website, new flatpak

Kube has a new website: kube-project.com

Screenshot_20180806_172259

It’s got a fresh, cleaner design, together with less, but hopefully more to the point, content.

What comes with it though is that we’ll also be publishing the flatpak and Mac OS nightlies there from now on. The CI that is building those nightlies will be integrated eventually, but that job is not complete just yet.

So update your bookmarks now, going forward kube-project.com will be the first stop for anything Kube.

Kube 0.7.0 is out!

I’m pleased to announce the immediate availability of Kube 0.7.0

Over the past year or so we’ve done a lot of work and building and maturing Kube and it’s underlying platform Sink.
Since the last publicly announced release 0.3.0 there have been 413 commits to sink and 851 to Kube. Since that diff is rather large I’ll spare you the changelog and will do a quick recap of what we have instead:

  • A conversation view that allows you to read through conversations in chronological order.
  • A conversation list that bundles all messages of a conversation (thread) together.
  • A simple composer that supports drafts and has autocompletion (assisted by the addressbook) for all recipients.
  • GPG support for reading and writing messages (signing and encryption).
  • Automatic attachment of own public key.
  • Opening and saving of attachments.
  • Rendering of embedded messages.
  • A read-only addressbook via CardDAV.
  • Full keyboard navigation.
  • Fulltext search for all locally available messages.
  • An unintrusive new mail hint in the form of a highlighted folder.
  • Kube is completely configuration free apart from the account setup.
  • The account setup can be fully scripted through the sinksh commandline interface.
  • Available for Mac OS.
  • Builds on Windows (But sadly doesn’t completely work yet).
  • The dependency chain has been reduced to the necessary minimum.

While things still change rapidly and we have in no way reached the end of our ever growing roadmap, Kube has already become my favorite email client that I have ever used. YMMV.

Outlook

Turns out we’re not done yet. Among the next plans we have:

  • A calendar via CalDAV (A first iteration is already complete).
  • Creation of new addressbook entries.
  • A dedicated search view.

While we remain committed to building a first class email experience we’re starting to venture a little beyond that with calendaring, while keeping our eyes focused on the grander vision of a tool that isn’t just yet another email client, but an assistant that helps you manage communication, time and tasks.

Tarballs

Get It!

Of course the release is already outdated, so you may want to try a flatpak or some distro provided package instead:

https://kube.kde.org/getit.html

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Notes on building C++ projects on Windows

Building C++ projects is bad enough, doing it on Windows is torture. The tooling sucks, the commandline sucks, the OS sucks. I might be biased.
I don’t think there’s a “good” way to build software for windows (Maybe it’s just using native tooling, I wouldn’t know), but here are some notes
on what I did, and perhaps it helps another poor soul out there trying to get something to work on windows.

Orchestrating the build

Unless your project is trivial, you will have to use something to orchestrate your builds. You will have to build all your dependencies (or cobble something together from installers on the internet…). Various solutions exist, none is any good.

Among the options are:

  • CMake with ExternalProject: Not much better than any other scripting language, but would work I guess.
  • Craft: Don’t expect everything to work out of the box, but it’s python and it’s fixable. It also covers everything from fetching the sources to building an installer, which is nice.

Build tools

For the individual parts that you build you’ll require some build tools. Whatever you think of CMake, when it comes to cross platform support there is just nothing better.

Wherever I could choose I chose CMake together with clang-cl which is the $MS style clang frontend.

That leaves you with the projects where you could not choose. In some cases it’s just easier to rewrite the buildsystem in cmake and get on with it.
In other cases you actually have to use an autotools buildsystem, so you have to resort to something like MSYS2.

Installer

There are few options for installers, and NSIS still seems like the easiest of the lot, and it works.

CI

You will have to touch that windows system for quite some time, but you’ll want to stop as soon as possible, so setup some CI solution to do the dirty work for you. Personally I’ve used Buildbot, I suppose Jenkins would work as well.

Qt/C++ notes

  • By default everything is hidden (which is the opposite of what we have on linux). Export explicitly what you want to use from a shared library.
  • Shared libraries consist of: a .dll containing the code, a .imp that contains the symbol table. All compiler specific.
  • C++ ABI is compiler specific. While it is possible to e.g. cross-compile a library from linux using mingwg and then link against that on windows,
    it’s not straightforward because you have to generate a .imp file that uses a mangling scheme that the compiler on windows understands (by default it wont work).
  • If you compile 64bit, all your libraries that you want to link against need to be 64bit.
  • If you use qt from the installer, add a qt.conf file to adjust the prefix. The compiled in paths for e.g. plugins won’t be available on the target system.
  • File paths passed to QML have to be converted with QUrl::fromLocalFile from a string. While absolute paths as strings work fine on unixes, it won’t work on windows.
  • Symlinks aren’t a thing on windows. For icon-themes (which make heavy use of symlinks), use a qrc file.
  • Qt is not deployed with SSL by default and tries to load the openssl libraries at run-time. Qt thus dictates which OpenSSL version you have to use. For Qt 5.9 OpenSSL 1.0.2o will work, for 5.10 you’ll need >= 1.1. Make sure you get 64/32bit depending on your Qt deployment. To deploy with the application I had to buld from source, but in general an installer like https://slproweb.com/download/Win64OpenSSL_Light-1_0_2o.exe will work as well (I did not manage to package the appropriate dlls from the installer though). QSslSocket provides functions to check whether the loading worked.
  • libcurl needs to be built with -DCMAKE_USE_OPENSSL=TRUE switch to have ssl support.

Windows survival tools

  • Get a backtrace: windbg, make sure you get the 64bit version.
  • strace: procmon.exe
  • Get debug output: DebugView.exe
  • The only barely usable terminal on windows is cmdr
  • It’s possible to setup ssh access to windows, but it will still be a pain to use.
  • Wireshark works on windows too.

Hints

  • Stay away from anything autotools if you can. It is often even easier to rewrite the buildsystem with cmake (sad, but true).
    • AWK scripts not working on msys2
    • buildsystems abusing compilers to generate code (hint; it’s not gonna work)
  • If ninja ends up rerunning the cmake configuration phase over and over in an endless loop, try checking out the source repository again. I think it has something to do with file timestamps…

Sources

Last but not least, here’s the code I’m using:

https://github.com/cmollekopf/craft-kube/tree/win
https://github.com/cmollekopf/craft-blueprints-kde/tree/kube
https://github.com/cmollekopf/craft/tree/kube

Last week in Kube

Last week in Kube

  • Kube builds on Windows and is largely functional. There is still an issue with Xapian not working and LMDB sparse files being broken on windows.
  • Date-range queries have been implemented.
  • The flatpak’s gpg-agent integration has been “fixed” (The proper fix will have to be done on the flatpak side of things).
  • A bunch of bugs in live-query updating have been fixed.
  • We now do some basic conflict resolution to avoid overwriting local changes with changes from the server.
  • Various visual glitches and and keyboard navigation issues have been fixed.
  • The generated message-id for new messages no longer leaks the local hostname.
  • Added tooltips for various UI elements.
  • Various message parser fixes, especially for apple mail generated messages with attachments.
  • The Logview has been renamed to Notifications View, and now only shows up if it also contains something.

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Last week in Kube

Perhaps if Windows wasn’t such a PITA there would be more progress 😉

  • The Conversation view received some vim-style keyboard bindings (because who uses a mouse anyways).
  • The INBOX is now automatically selected when Kube is started, so we show something useful immediately.
  • Progress on Kube for Windows. Everything builds, but there are still a couple of remaining issues to sort out.
  • Ported from QGpgME to plain old GpgME. This was a necessary measure to build Kube on Windows, but also generally reduced complexity while removing the dependency on two large libraries that do nothing but wrapping the C interface.
  • Ported away from readline to cpp-linenoise, which is a much simpler and much more portable replacement for readline.
  • Rémi implemented the first steps for range queries, which will allow us to retrieve only the events that we require for to e.g. render a week in the calendar.
  • The storage layer got another round of fixes, fixing a race condition that could happen when initially creating the database for the first time (Blogpost on how to use LMDB).
  • The IMAP resource no longer repeatedly tries to upload messages that don’t conform to the protocol (Not that we should ever end up in that situation, but bugs…).
  • The CalDAV/CardDAV backends are now fully functional and support change-replay to the server (Rémi).
  • The CalDAV backend gained support for tasks.
  • Icons are now shipped and loaded from a resource file after running into too many problems otherwise on Windows.
  • A ton of other fixes for windows compatiblity.
  • A bunch of mail rendering fixes (also related to autocrypt among others).
  • Work on date range queries for efficient retrieval of events has been started.

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Last week in Kube

Kube by now is my daily driver, and we’ve managed to iron out a lot of the remaining kinks since the last update.

  • Rémi is now on board Blogpost
  • Xapian based search is alive and kicking Blogpost.
  • Search in conversationview via syntaxhighlighting.
  • Support for operations on aggregated values (such as threads). This allows us to i.e. mark an entire thread as read.
  • Fixed rendering of encrypted+signed messages.
  • Forwarding of encrypted mails (so they are properly re-encrypted to the recipient) (Rémi)
  • A revamp of the Addressbook (Michael)
  • Support for GPG key import and export (attaching the key to the mail) (Rémi)
  • We now highlight folders that contain new mails.
  • We’ve got a experimental but working build on mac (gpg not withstanding) Blogpost
  • Michael and Rémi are spearheading calendaring in Kube! (we’ve already merged first versions of calendar view and CalDAV backend)

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Last week in Kube

New year, new Kube =)

  • Setup a clearer structure for the application with “Views” as the highest level components (composer, conversation, addressbook, log, accounts).
  • Made sure that individual views are self contained and can be launched using qmlscene. This is not only good for modularity, but simplifies the workflow when working on the UI.
  • Improved the test and prototyping infrastructure: Blogpost
  • A little investigation in where all the memory goes: Blogpost
  • Added an extension mechanism that allows us to easily experiment with new views, without compromising the main application.
  • Support to unlock kube from the commandline as a poor-mans keyring integration.
  • A rather large cleanup of encryption related code used in the message parser got rid of over 1k SLOC.
  • The encrypted/signed state of a mail is now properly visualized.
  • A storage upgrade mechanism was added (Although upgrading for now means removing all local data).
  • Large payloads are no longer stored externally but inline in the database. Tests have shown that this is not less performant, but improves the fault resiliency and simplifies the system.
  • A first version of Xapian based fulltext search for local content just landed (Blogpost will follow).
  • As always, a variety of bugfixes.

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Last week in Kube

Ooops, skipped a couple of weeks. Development did not stop though, although there was some infrastructure work to be done and less user-visible changes therefore.

Temporarily reverted the commit to demonstrate incremental query performance improvements.

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

Kube: Finding our Focus

Over the past two years we’ve been laying the ground work towards the first goal of a simple and beautiful mail client.
By now we have the first few releases out, and the closer we get to our goal, the less clear becomes what the next goal on our roadmap is.

So here’s something that we’ll be focusing on:kolabnow_logoAn obvious reason why we picked Kolab Now is because it is what sustains the larger part of the Kube team, allowing us to work on this project in the first place. However, it’s also a prime example of a completely Open Source and standards compliant service. Improving the Kolab experience means improving IMAP support, improving the CardDAV implementation, perhaps even adding CalDAV. It also means implementing proper GPG support, and pushing the user experience edge by edge to where we expect it to be. Things that all standards compliant services will benefit from. The Kolab Now service ensures we can focus on the relevant problems by taking variables out of the equation by being essentially the reference installation of Kolab.

Now, this means that we’ll be putting a little more focus on the single account experience, it does not mean we’ll be dropping support for multi-account setups though. The develop branch (which will lead to the next release) will continue to support multiple accounts and account types. What we will do though is acknowledge that very little testing is happening with other services than Kolab, and that we will probably not prioritize any features that are exclusive for other services (such as GMail’s non standard IMAP behavior) in the near future. It’s about focus, not exclusion.

There are many other goals ahead of course, that’s not the problem. Various platforms to be conquered, CalDAV access to our calendaring data, perfecting the mail experience, a beautiful calendar view, working out the grand scheme of how we tie all these bits together and produce something unique… Lot’s of exciting stuff that we’re looking forward to be working on!

However, it’s also easy to get lost in all those possibilities. It’d be easy to hack together some half-baked implementations for a variety of those ideas, and then revise those implementations or just pick the next bit. But that doesn’t lead to what we want. We want a product that is actually used and just works, and that requires focus. Especially since we’re a small team, it’s more important than ever that we maintain, if not increase, our focus. Kolab Now gives us something to focus on.

Kube for Kolab Now

With that said, I’d like to announce the Kolab Now edition of Kube, that we’ve made available as an early access release.

Kolab Now Configuration
Kube’s simplified account setup for Kolab Now.

This is a completely separate release-stream that supports Kolab Now exclusively, and does not replace general purpose Kube releases. But it is not a separate codebase (For simplicity there exists a kolabnow release branch with a two-line patch, but that’s all there ever will be).

We’ll regularly update this release to share our latest developments with you.

If you already are, or would like to become a Kolab Now user, then you’re welcome to join us on our journey to bringing you the best possible Kube experience to your desktop. You’re not only going to profit from a great service, but you’ll also help sustain the development of Kube.

For future updates, keep an eye on blogs.kolabnow.com

Last week in Kube

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

  • Added support for secret distribution to resources in sink. This will be the base for avoiding passwords in configuration files.
  • Added a simple in-memory keyring in Kube. Doesn’t persist the password yet as we have no secure storage.
  • Simplified the configuration dialog to only require name + email address
  • Moved the password entry into a separate view so we can request the password on startup if not available.
  • Fixed keyboard focus in configuration and password view.
  • Fixed indefinitely growing webviews. This was a problem with mails that would always grow one pixel larger than what was available which lead to a resize cycle.

Kube Commits, Sink Commits

Previous updates