<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Lukas Bombach on Medium]]></title>
        <description><![CDATA[Stories by Lukas Bombach on Medium]]></description>
        <link>https://medium.com/@luke_schmuke?source=rss-aa368c86d466------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*rFg9Tj982ZCJHTUr9sbx_w.jpeg</url>
            <title>Stories by Lukas Bombach on Medium</title>
            <link>https://medium.com/@luke_schmuke?source=rss-aa368c86d466------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 07:37:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@luke_schmuke/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How we achieved the best Web Performance with Partial Hydration]]></title>
            <link>https://medium.com/@luke_schmuke/how-we-achieved-the-best-web-performance-with-partial-hydration-20fab9c808d5?source=rss-aa368c86d466------2</link>
            <guid isPermaLink="false">https://medium.com/p/20fab9c808d5</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[server-side-rendering]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Lukas Bombach]]></dc:creator>
            <pubDate>Wed, 22 May 2019 15:03:48 GMT</pubDate>
            <atom:updated>2019-05-22T15:03:48.978Z</atom:updated>
            <content:encoded><![CDATA[<h3>The case of partial hydration (with Next and Preact)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-Lu-u6OoL4Y9OVoZrS9MQ.png" /></figure><p>At Spring, we are responsible for maintaining various different news media websites for our parent company, Axel Springer. One of our latest releases, welt.de, is the fastest news media website in Germany; one of our most sought after goals is to continually achieve the best performance possible and the reason for this is simple: better performance usually means a better user experience and thus a higher user-retention.</p><h3>tl;dr</h3><blockquote>Scroll down to “Recap” for a short summary with an infographic. The key points for this in a nutshell:</blockquote><ul><li>Performance is crucial for the web</li><li>to achieve high performance we want to send as little as possible to the client</li><li>we can do this by choosing the components we want to send and hydrate to the client</li><li>we leave the rest of the page static and have multiple render roots</li><li>All of this works with a single code base</li><li>Below is a lengthy article on how we implemented the steps noted above. You will also find a link to a WIP repo of this implementation here:</li><li><a href="https://github.com/spring-media/next-super-performance">https://github.com/spring-media/next-super-performance</a></li></ul><h3>Performance on the web</h3><p>If you follow <a href="https://twitter.com/addyosmani">Addy Osmani</a> you already know the drill, he writes a lot about the cause and effects of performance on the web. To get you started, I can recommend Addy’s article on “<a href="https://medium.com/@addyosmani/the-cost-of-javascript-in-2018-7d8950fbb5d4">The Cost Of JavaScript In 2018</a>”. Two very important things you can learn from this article are:</p><ul><li>The cost of JavaScript is not only the time it takes to load your bundle</li><li>The time to parse and execute your JavaScript is just as crucial</li></ul><p>Of course there is a lot more to performance than this, including loading strategies, a critical rendering path, performance budgets and so forth. All of these things revolve around how to optimize whatever you end up sending to your client. What we want to focus on with partial hydration is not how to optimize what you send, but how much you send at all.</p><p>A key aspect of this will be server side rendering (SSR) because there is a lot we can do on the server that does not need to be done on the client. In fact, this is the crux of this article; Whatever can be done on the server should be done on the server but the client should only be sent whatever needs to be executed on the client side. Additionally, you can still apply everything you know about web performance but you’ll have far fewer factors to manage, this will be explained in depth further on down the article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*6beeih6tJfxKKuntuSqTrw.png" /></figure><h3>SSR and hydration</h3><p>In order carry out our objective of building a performant website we will be using a modified version of Next. Next comes bundled with plenty of built in performance enhancing features, most importantly, Next does server side rendering (SSR) out of the box. This means that Next will take your app, written in React and in this order:</p><ol><li>Render it as an HTML string on the server</li><li>Send the rendered HTML string to your users as source code</li><li>Send your React code as JavaScript to your users</li><li>And then finally “hydrate” your HTML using your React code</li></ol><p>To “hydrate” in this case means that Next will roll out your React code over your HTML and then tell React something a little like this:</p><blockquote>Hey React, here’s some HTML that matches exactly what you would render if I told you to render in an empty DOM node, please do not re-render everything, instead, please just use the HTML as if you had rendered it and carry on with your day</blockquote><p>React will answer</p><blockquote>Ok, I just looked at you HTML and it seems to match exactly what I would have rendered. It’s cool. I’ll just attach some event handlers to your DOM and your page now acts as a single page application like I did it all myself in the first place.</blockquote><p>The benefits of loading a website in this way are simple: Your users will already see a fully rendered page when they load your website (instead of a blank page) <em>and then</em> it becomes interactive. Your website will also benefit from a major performance improvement because the browser does not need to do any repaints (re-rendering your page with React).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tEPpxXrrNXS3MXiqioGAEQ.png" /></figure><h3>Too much overhead</h3><p>This approach is fantastic when you want to create web <em>applications</em> or in other words websites that need to be fully controlled by JavaScript and are also interactive wherever you click. Examples of this approach in production include websites like Facebook, Twitter and web-based email clients.</p><p>But most websites aren’t like this, most websites are kind-of-static and also contain some interactive elements.</p><p>Now you end up sending your entire application code to your users including React components for every headline or text paragraph anywhere on your page. The result is an unnecessarily huge bundle that needs to be loaded, parsed and executed. This results in suboptimal performance, your page will be slow(er) especially for mobile users and for no good reason!</p><p><em>And that sucks.</em></p><p>So what can we do? Well, there are lots of strategies and products out there. One of the most prominent ones is <a href="https://www.gatsbyjs.org/">Gatsby</a>, a static site generator (I’m sure you’ve heard of it by now) which focuses heavily on performance optimization. The issue with Gatsby is that it has to generate all of your pages and subpages at compile time which does not really work when you have sites linked to a CMS that updates everyday and that hosts millions of articles—which is exactly what we need for our news media sites. This is why we are using Next as well as modifying it to suit our needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AEZrX0pR3CffXYgt5ApmvQ.png" /></figure><h3>Enter partial hydration</h3><p>To solve the above mentioned problems we came up with something we like to call <em>partial hydration</em>.</p><p>If you have looked into this topic you probably will have come across terms like <em>progressive hydration</em> or <em>lazy hydration</em>. They don’t all mean the same thing specifically but they are all interrelated and belong in the same sphere.</p><p>The basic idea behind our version of partial hydration is: Instead of doing SSR and then sending your entire application to your client, only parts of your application’s JavaScript would be sent to the client to hydrate the parts of your website which specifically require JavaScript to work. If you were to create a website using such a method you would have multiple tiny React ‘apps’ with multiple render roots on your otherwise static website.</p><p>Doing things in this way should give your website a massive performance boost because what you end up shipping is plain HTML, CSS and the least amount of JavaScript required for your page. One thing to note, when measuring performance you must not only factor in loading time but also parsing and execution time as well.</p><p>You can also choose to implement proper performance strategies on top of all of this, like code-splitting, caring for the TCP slow start and your critical rendering path etc.</p><h3>Our implementation</h3><p>Our implementation consists of 2 packages:</p><ul><li>The Preact library for partial hydration called <em>pool-attendant-preact</em></li><li>The Next.js plugin called <em>next-super-performance</em></li></ul><p>The latter library is just a plugin for Next.js that uses <em>pool-attendant-preact </em>so let’s concentrate on <em>pool-attendant-preact</em>. I may write a followup post on next-super-performance at some stage in the future.</p><h4>pool-attendant-preact</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TSvjGxPfVNoagzlCNmx9Gw.png" /><figcaption>Layout with a header, body, sidebar and 2 reactive elements</figcaption></figure><p>Picture this layout and let’s pretend the grey boxes are elements that can be completely static and you want the ones in purple to be interactive. For instance, the larger one could be a Twitter feed and the smaller one a tiny voting tool. So we need to apply JavaScript to these elements to make them interactive and we want to leave the rest as static elements.</p><p>An example implementation for this using <em>pool-attendant-preact</em> could look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/63dd8ec615343c164592b024aa16e37b/href">https://medium.com/media/63dd8ec615343c164592b024aa16e37b/href</a></iframe><p>Lines 3–8 are all the components we want to display, these components will be rendered on the server and then sent as HTML and CSS to the client without any JavaScript whatsoever.</p><p>Lines 10 &amp; 11 are where we mark the components TwitterFeed and Poll for hydration and get a new component in return. Lines 18 &amp; 19 are where we use them.</p><p>Line 22 is of utmost importance. This is a component that injects hydration data (props and component names) into the page.</p><p>But let me explain. When we do a <em>normal</em> hydration with react, your code looks something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/911fc94435348641d4b478b2199fad24/href">https://medium.com/media/911fc94435348641d4b478b2199fad24/href</a></iframe><p>There are 2 problems we need to solve here when we do partial hydration</p><ol><li><em>ReactDOM.hydrate</em> operates on a root node in the DOM, the node that it uses as a starting point for the hydration. That root node must contain a server-rendered DOM tree that matches your app’s components and state. The catch: You need to explicitly name a DOM node to act as a root node. In this example, this is simple, you can give that node an id, use document.getElementbyId and then throw that node into ReactDOM.hydrate and 🎉 you’re done! <br>Partial hydration on the other hand means that you will have multiple DOM elements on your static page that you need to hydrate. You wouldn’t want to explicitly name them all that would be tedious work for the developer.</li><li>What if HydrateTwitterFeed or HydratedPoll need props that need to be passed on to them? Say, something like &lt;HydratedTwitterFeed user=&quot;luke_schmuke&quot; /&gt;<em>.</em> If we want to run ReactDOM.hydrate(&lt;TwitterFeed user=&quot;luke_schmuke&quot; /&gt;, rootElementOnThePage) where would we get the luke_schmuke from? How would a static page know about this? We need to somehow store and send them to the client.</li></ol><h4>Solution</h4><p>The way we tackled this problem can be understood from the implementation of <em>withHydration</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/92e96c8bb63b1d3c4cd50a8e6780dc40/href">https://medium.com/media/92e96c8bb63b1d3c4cd50a8e6780dc40/href</a></iframe><p>Let’s take a closer look at this: withHydration works using the higher order component technique, the higher order component returns the original component along with its original unaltered props but it also prepends it with a &lt;script&gt; tag called hydration-marker. This solves our 1st problem by finding our render roots in our server side rendered page. It works like this, the server will use the HOC (higher order component) to render something like this</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8af465582a0af6763b82b9eb2aead2a5/href">https://medium.com/media/8af465582a0af6763b82b9eb2aead2a5/href</a></iframe><p>Everything in &lt;div class=&quot;twitter-feed&quot;&gt; is passed down from the TwitterFeed component. The &lt;script&gt; prepending &lt;div class=&quot;twitter-feed&quot;&gt; comes from our HOC. Now that the server rendered bits and pieces have been loaded some client side JavaScript could for instance search for script[type=&quot;application/hydration-marker&quot;] and assume that any element directly following the script should be hydrated. It’s also possible to use wrapper elements but that would be too intrusive and it could potentially break your layout.</p><p>To address problem #2 let’s take another closer look at the code, lines 5 and 8 of <em>withHydration.js</em>. In line 5 we store the props passed to HydratedTwitterFeed. In our initial example we passed no props at all but if we did something like &lt;HydratedTwitterFeed user=&quot;luke_schmuke&quot; /&gt; we would now have the following object stored:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/615d36e451e8fd9e07036e2e359fc1fd/href">https://medium.com/media/615d36e451e8fd9e07036e2e359fc1fd/href</a></iframe><p>Now our hypothetical <em>client.js</em> could hydrate our component using the DOM element adjacent to our marker using the props that we stored earlier.</p><blockquote>But hey, how does the client.js access the data we stored earlier?</blockquote><p>This is when &lt;HydrationData /&gt; comes into play. When using this component all the data we have stored using HydrationData.storeProps will be rendered as serialized JSON to the HTML. This process mimics how Next.js renders NEXT_DATA and how Apollo renders APOLLO_DATA.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/81313d60e35affdd37b3aef1477a250d/href">https://medium.com/media/81313d60e35affdd37b3aef1477a250d/href</a></iframe><p>Also note that calling HydrationData.storeProps will return and ID that we then pass on to the hydration marker, this way we can map the data in &lt;HydrationData /&gt;<em> </em>to its corresponding markers and DOM elements</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A1tpWPreesKWQ9VNuIs2jA.png" /><figcaption>hydration flow</figcaption></figure><p>This is how the hydration part on the client would work:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a6e6da3012ac53e8e30d93ef8cff7e5/href">https://medium.com/media/3a6e6da3012ac53e8e30d93ef8cff7e5/href</a></iframe><ul><li>First, find all markers on the page</li><li>Next, find the hydration data and load it</li><li>And finally, iterate over all the markers and get their subsequent DOM elements and hydrate them using Preact’s render</li></ul><p>You may have noticed that in this example we have a component called Teaser which is used to hydrate all of our elements. In our super-intendant-preact module we expose a function called hydrate which enables you to create a component like Teaser to hydrate multiple components.</p><h3>Recap</h3><p>There’s a lot of information to take in from this article, my purpose for writing about the subject was to illustrate our particular method of using partial hydration and to explain how it works. If you would like to dive deeper into the code behind this article then please have a look at our GitHub repository:</p><blockquote><a href="https://github.com/spring-media/next-super-performance">https://github.com/spring-media/next-super-performance</a></blockquote><p>Here’s a helpful infographic to help you visualize our partial hydration method a little better:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HjqLTuZzCfSWQGncCzjo0w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H-ef1avpsUhESE9kQW0oQg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VPjlX-Sg2zHJxF3vSuYsKA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1SlmBnrvrmEobb4aPo0HrQ.png" /></figure><h3>Conclusion</h3><p>*Our approach to using partial hydration works quite well, we have already used a similar method with Vue which has proven to be successful. I expect to see more written about this topic in the future, some people within the web development community have been working on their own partial hydration methods, the developers behind React have begun to take notice of this so we may see some partial hydration features being incorporated into React’s core in the future.</p><p>We like to ship as little code as possible to ensure that we end up with more performant websites which in turn deliver a better user experience, after all, the smaller the codebase the smaller the bundle the user ends up having to deal with. Partial hydration enables us to do this without compromise while using the tooling and eco system of modern web development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20fab9c808d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[So you’re looking for the VLC web plugin?]]></title>
            <link>https://medium.com/@luke_schmuke/so-you-re-looking-for-the-vlc-web-plugin-ba058e17ecb?source=rss-aa368c86d466------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba058e17ecb</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Lukas Bombach]]></dc:creator>
            <pubDate>Sat, 02 Apr 2016 18:36:37 GMT</pubDate>
            <atom:updated>2016-04-02T18:36:37.593Z</atom:updated>
            <content:encoded><![CDATA[<p>This is a quick one: I was trying to find the VLC web plugin but could not find it, even if it is supposed to be here or there. But finally I found it in VLC’s file index.</p><p>Current Version (2.2.2): <a href="http://download.videolan.org/pub/videolan/vlc/2.2.2/macosx/VLC-webplugin-2.2.2.dmg">OS X</a></p><p>Ok I got too overexcited, I can’t find a link for Windows. Anyways, if you wanna find out yourself or if 2.2.2 is not the most recent version anymore you can find</p><p><a href="http://download.videolan.org/pub/videolan/vlc/">all VLC files for all versions and platforms here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba058e17ecb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quick notes on Lisbon from a computer scientist]]></title>
            <link>https://medium.com/@luke_schmuke/quick-notes-on-lisbon-from-a-computer-scientist-9e21cacc6388?source=rss-aa368c86d466------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e21cacc6388</guid>
            <category><![CDATA[lisbon]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[travel]]></category>
            <dc:creator><![CDATA[Lukas Bombach]]></dc:creator>
            <pubDate>Fri, 11 Sep 2015 23:34:43 GMT</pubDate>
            <atom:updated>2015-09-11T23:36:09.054Z</atom:updated>
            <content:encoded><![CDATA[<p>So, I have been in Lisbon for 7 days and as a computer scientist I noticed a few things. I live in Berlin, or rather, I live in Germany. Germany, in terms of Internet and all things related to modern technology, kinda sucks. Here are a few random things I found quite remarkable — from a computer scientist’s point of view.</p><h4>Public transportation</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rRXm7POH_Vpfe_6NE6tmtw.jpeg" /><figcaption>3 wires and a chip interwoven in a paper card. Public transportation in Lisbon.</figcaption></figure><p>The public transportation system is pretty cool. You can buy a <em>reusable paper</em> ticket at any metro/train station. But don’t be fooled, even though it’s paper, there is actually technology inside — you can see some circuits when you hold it against the light. To ride the metro, the bus, a train or a ferry, you simply hold your ticket against a scanner and you’re all set. The machines to buy cards from, can also reload the card with credits, so you can use the same card over and over again.</p><h4>Buying tickets for the aquarium</h4><p>My friend and I went to the aquarium (btw it’s awesome). When we got there, we were kind of annoyed of ourselves, because there were about 150 people waiting to buy tickets. But: there was also a pole with a sign saying “free wifi to buy tickets online” — and it worked. Why not every museum on earth has one of these is beyond me.</p><h4>Random wifi hotspots</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c-LbwfndUr-Vk3Ij18nUfw.jpeg" /><figcaption>Wifi, because why not.</figcaption></figure><p>So wifi to buy tickets is cool. But there are also random sings providing free wifi for no particular purpose. How cool is that?</p><h4>TV</h4><p>So, I am German. I do watch movies and tv shows. If you grow up in a country where English is your native language, cool. If you grow up with dubbed tv and start to find out how your favorite tv shows sound and <em>feel like</em> in English, you kind of lose faith in humanity. Unfortunately, German tv won’t be broadcasted with original audio, even though digital tv has capabilities for switching between languages. I am currently sitting in some local’s Airbnb flat in Lisbon watching Braveheart in English (I think ;)), which kind of is the weirdest, but also coolest thing to do on a holiday.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e21cacc6388" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seamless retro gaming with the Raspberry PI]]></title>
            <link>https://medium.com/@luke_schmuke/seamless-retro-gaming-with-the-raspberry-pi-caff967b17e?source=rss-aa368c86d466------2</link>
            <guid isPermaLink="false">https://medium.com/p/caff967b17e</guid>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[retrogames]]></category>
            <category><![CDATA[htpc]]></category>
            <dc:creator><![CDATA[Lukas Bombach]]></dc:creator>
            <pubDate>Tue, 11 Aug 2015 19:23:30 GMT</pubDate>
            <atom:updated>2015-08-12T09:30:27.525Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*emDcTv6HiACjfhsgLe_N1w.png" /></figure><p>For years I have been kind of obsessed with trying set up a HTPC that will not only play movies, but also run retro games from systems like the SNES, Sega Genesis / Mega Drive, Neo Geo or the NES.</p><p>It was never enough for me to just be <em>able</em> to play games — I wanted to boot up my HTPC and be presented with a <em>slick</em> (do people still say that) UI without seeing Windows’ Desktop or that of any other OS.</p><p>For a long time I have been using XMBC Live, a Linux distribution that will boot directly into XBMC (now <em>Kodi</em>), and tried out various plugins to display roms and run emulators directly from the media center.</p><p>A while ago I got in touch with some alternatives and today I will <em>briefly</em> review 3 options for making this possible with the Raspberry PI. These options are <a href="http://blog.petrockblock.com/retropie/"><strong>RetroPie</strong></a>, <a href="http://www.lakka.tv/"><strong>Lakka</strong></a> and <a href="http://kodi.tv/"><strong>Kodi</strong></a>.</p><h2>RetroPie</h2><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CREVtVouqGPV1o_u1TSojQ.png" /><figcaption>The EmulationStation front end</figcaption></figure><p>Homepage: <a href="http://blog.petrockblock.com/retropie/">http://blog.petrockblock.com/retropie/</a></p><p>The RetroPie setup is pretty simple, just <a href="http://blog.petrockblock.com/retropie/retropie-downloads/">download the disk image</a> for your Raspberry 1 or 2, install it on your SD card and the system is set up.</p><p>The system will boot directly into EmulationStation, an arcade front end, where you can select the consoles and other system you want to emulate. It is not necessary for you to install emulators, <a href="https://github.com/retropie/RetroPie-Setup/wiki#emulators">most emulators you need are pre-installed</a>. However, you need to add roms yourself (duuuh) — before your emulators show up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mtQGnJz-Sn33WNggW6BxtA.png" /><figcaption>EmulationStation’s rom browser</figcaption></figure><p>Rating ★★★★☆<br>It works great but I do not fancy the UI design so much.</p><h2>Lakka</h2><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FbmfoXVayTTgXn3xkJfP-Q.jpeg" /><figcaption>Lakka’s interface</figcaption></figure><p>Homepage: <a href="http://www.lakka.tv/">http://www.lakka.tv/</a></p><p>Lakka, just like RetroPie, can be <a href="http://www.lakka.tv/get/linux/">downloaded as a disk image</a> for your Raspberry Pi. However, the website claims it is not fully stable und RasPi2.</p><p>Its interface looks much like Sony’s Playstation interface ‘XMB’ (duuh again) — with a pretty retro touch. It’s built on top of RetroArch so it will play most consoles out-of-the-box, well at least eventually. It is still under development, so not everything is working yet.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F3O953RQOZTw%3Ffeature%3Doembed&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D3O953RQOZTw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F3O953RQOZTw%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/797490341bed1e66e6206dd99221a4e4/href">https://medium.com/media/797490341bed1e66e6206dd99221a4e4/href</a></iframe><p>Rating ★★★☆☆<br>It’s still <em>work in progress</em> so I can’t give it more stars, but I see a bright future.</p><h2>Kodi + Adv. Launcher</h2><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ED95nxCruN9xkIP78hpihg.jpeg" /><figcaption>Kodi’s start screen</figcaption></figure><p>Homepage: <a href="http://kodi.tv/">http://kodi.tv/</a></p><p>So, Kodi is a <em>media center</em> software, not an arcade front end and neither made to be distributed as a Raspberry Pi disk image. But: People made distributions / disk images for the RasPi: <a href="http://openelec.tv/">OpenELEC</a>, <a href="https://osmc.tv/">OSMC</a> and <a href="http://www.xbian.org/">XBian</a>.</p><p>Here’s the disclaimer: It is a struggle and will probably always be a struggle to set this up and have a seamless experience and it does require some nerd-skills. And from my experience a high level of frustration.</p><p>So why would you want to do this? Because this is a media center software it will also play all your videos, streams, music, show picutes and will do tons of more stuff — and you can boot roms directly from Kodi, with box art images to select your games and everything. Also you have a wide selection of skins to choose from.</p><p>To start your games directly from Kodi and have cool box art images your select your games with, you need to manually install emulators and install and configure the extensions ‘Advanced Launcher’ or ‘Rom Collection Browser’. Box art images will be scraped automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OIX3sWkLczQyvXAnJ9g8kw.png" /><figcaption>This is just one of the views to display your roms.</figcaption></figure><p>Rating ★★☆☆☆<br>Do this only if you are up for a challenge and you want a full media center.</p><h2>Conclusion</h2><p>To put it in a nutshell: Use RetroPie if you want a <em>no-hassle</em> solution that <em>just works</em>. Watch out for Lakka, it might become pretty cool. If you feel like trying out stuff, why not give it a spin. If you are pretty much of a nerd and you crave that one device that will do everything you need for your home entertainment, go with Kodi, but be warned, it will drive you mad at some point.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=caff967b17e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>