Mike Blumenkrantz

Mike Blumenkrantz

About Mike Blumenkrantz

Mike is the release manager for Enlightenment as well as a core developer of the EFL toolkit. He sometimes contributes to the Servo application embedding API/ABI, and in his free time he attempts to write desktop applications.

  • Projects

    EFL, Servo
  • Role

    Senior Staff Engineer

Posts by Mike Blumenkrantz

  • July 11, 2016 - Mike Blumenkrantz

    How to Create Enlightenment Gadgets

    Creating desktop widgets, aka “gadgets,” has never been easier for Enlightenment enthusiasts than it is after the E21 release. The new E_Gadget system provides an updated API for integrating objects into the compositor, removing most of the overhead from the E_Gadcon system. This makes writing gadgets nearly identical to ordinary application writing. This post will serve as an introduction on the topic of writing gadgets with a focus on the basics; it will use the Start gadget as a reference. How to Create a Gadget The first step to integrating a new gadget is to add the new gadget type to the subsystem so the user can access it. This is done with the following function:

    This function coincides with related callbacks:

    Using e_gadget_type_add, a developer can implement gadgets of type, calling callback to create the gadget object, and optionally providing wizard callback to run configuration options for […]

    Read More
  • June 10, 2016 - Mike Blumenkrantz and Derek Foreman

    Upcoming Enlightenment Improvements: DMABuf & Teamwork V2

    E21 has been under heavy development since December of last year; the primary goals for have been to provide a more rapid release and expedite improvements in Wayland compositing to provide a much more usable experience. With the release pending, here’s a roundup of a couple recently-added Wayland features that are coming in this release. Improving Memory Sharing for Video Processing with DMABuf DMABuf is an infrastructure for sharing memory between various pieces of hardware. It’s a key technology to enable a high performance video pipeline without wasted memory copies, but its benefits aren’t limited to video processing and playback. EFL and Enlightenment now both support the Wayland DMABuf protocol, allowing clients to create buffers that can be dropped into a hardware video plane or used as a texture by the GPU, without the inherent memory copy required for wl_shm buffers. While this is good news for video players, we’ve […]

    Read More
  • May 6, 2016 - Mike Blumenkrantz

    Wayland Recovery: A Journey Of Discovery

    Wayland on the desktop is a constantly evolving project. Whether it’s improvements to the drag-n-drop protocol or extreme functionality enhancements in the client-side decorations, Wayland is a fast-moving target which allows developers to shape it in almost any way they desire. However, there are some limitations to a Wayland compositor when compared to X11 window managers. Under X11, a window manager is just a client of the XServer; this allows it to do things like restart itself without killing the user’s session. In Wayland, a restart of the running session’s compositor disconnects all the active clients, causing them to terminate. This increases the difficulty of things like crash handling where the environment can gracefully restart itself if there’s a crash. How to Crash Gracefully This is where a newly-created extension comes into play: the Session Recovery Extension. With Session Recovery enabled, a client is able to reconnect to the compositor […]

    Read More
  • April 1, 2016 - Mike Blumenkrantz and Derek Foreman

    CSS: Revolutionizing the Appearance of the WWW

    One of the most notable and enduring Linux desktop paradigms has been desktop effects: the coupling of various desktop environments with graphical niceties, also known as “eye candy.” With the advent of the XComposite extension in the mid 2000s, mainstream eye candy was taken to new levels through a small project called Compiz which used the texture from pixmap extension to apply hardware-accelerated effects to windows on the fly. From Compiz came the effect that is known throughout the Linux world as “wobbly windows” or, for many developers, “that feature we aren’t implementing.” By applying OpenGL vertex transforms to the textures created using the previously-mentioned extension, windows would appear to deform when moved and resized. This has persisted in being the benchmark for all graphical desktop effects for a decade, and numbers may not go high enough to enumerate all the users who have asked for this effect in Enlightenment […]

    Read More
  • January 8, 2016 - Mike Blumenkrantz

    Desktop Compositing: How Much Overdraw Is Too Much?

    In my previous post on compositing, I covered the overall methodology with which I implemented Compiz plugin support in the Enlightenment compositor. Now I’m going to go into some detail about the rendering portion. The first thing that should be reiterated is Compiz only performs damage calculations for the entire screen and does not track them per-window. This is, to say the least, problematic. There’s no way to easily predict where a window will draw at any given time either: there are window effects that cause clients to zoom in/out to/from the mouse cursor, and others that cause the client to bounce around outside of its frame region. The compositor must be prepared to draw things for each window at any geometry on the screen at any time, regardless of common sense clipping. Rendering Outside the Box The first attempt I made at getting things to work was to just […]

    Read More
  • December 21, 2015 - Mike Blumenkrantz, Josh Matthews and Lars Bergstrom

    Adding Community-Driven Wayland Support to Servo

    It’s been some time since the last Servo article on the OSG blog, but this has no relation to the speed at which the browser engine’s development has been progressing. In the last post, the Offscreen Rendering (OSR) integration status was explored, culminating in both some code snippets as well as videos of an embedded browser application. That post can be considered the foundation for the recently-tweeted screenshot of Servo running with Wayland support. The Technical Hurdle Before delving into the technical details of Wayland integration, it’s important to know the background of Servo’s rendering stack. In order to provide support for a broad range of platforms, Servo uses the rust-layers library to create hardware-accelerated drawing abstractions for Android, Linux, MacOS, and Windows; this enables the browser engine to use a unified API for all its internal compositor painting. Under Linux, rust-layers uses GLX, the OpenGL extension for X11, to […]

    Read More
  • December 11, 2015 - Mike Blumenkrantz

    Manual Compositing with Compiz and Enlightenment

    This is the first article in a two part series on compositing with Compiz and Enlightenment. I recently implemented  a proof of concept for Compiz effect modules in the Enlightenment compositor. In this article, I will explore the methodology behind the implementation and cover some of the AWESOME hacks that made it possible. Replacing Default Compositor Behaviors with Compiz To start, let’s examine how Compiz operates. There is an OpenGL extension that allows an X11 pixmap to be bound to a texture. Compiz operates based on the principle that the compositor can render this texture in any way, at any time, and the underlying X11 input window will be moved quietly to wherever the rendered content ends up. This creates the illusion that the entire window (input and output) is moving in an irregular manner, when in reality, the window’s output is moving around and the window’s input region is […]

    Read More
  • June 1, 2015 - Mike Blumenkrantz and Lars Bergstrom

    Servo: The Countdown To Your Next Browser Continues

    Huge progress is being made on the Servo browser engine, and development continues moving forward at full speed. Now, it’s even possible to write applications that embed Servo to display web content, and these applications can drop Chromium in at any point, with very few changes, in order to have a more functional product while Servo continues its heavy development. This article will take a look at the new code that provides this detection ability to toggle functionality based on the running engine, in addition to the new improvements that have been introduced to Servo’s rendering and embedding capabilities. Detecting Servo to Work in Harmony With Chromium Detection of the engine is made possible by a symbol added into Servo’s embedding library, which can be detected in C with a bit of code like this:

    This returns the address of the symbol and sets a boolean variable “servo” based […]

    Read More
  • May 13, 2015 - Mike Blumenkrantz and Lars Bergstrom

    Servo: The Embeddable Browser Engine

    Embedding, in the context of this article, is the process of hosting a web rendering engine inside another application. This engine displays content exactly as a regular web browser would, but allows the application author to customize the user’s experience further than what is possible in the typical display of a normal website. Development time can be reduced by keeping part of the content of an application in web-related languages due to the relative ease of writing web content and the widespread knowledge of HTML5. The technique of embedding web content is used in many places by many companies, including: Popular Linux applications such as Rhythmbox, Kate, Eclipse, and Evolution have support for embedding web content. Microsoft Entourage and Apple Mail for Mac OS both utilize embedding for displaying web content and parts of the UI. Adobe products, including their constantly-running updater, embed full web runtimes. Valve’s Steam client also […]

    Read More
  • April 22, 2015 - Lars Bergstrom and Mike Blumenkrantz

    Servo: Building a High-Performance, Safe Web Browser

    Servo is a new web rendering engine that was launched by Mozilla in 2012 and is now receiving significant contributions from both Samsung and independent community members. Our goal is to produce an embeddable engine that can be used in both browsers and applications to make the web platform faster and safer, and bring it to more devices. We started this project to address fundamental limitations of current browser engines. First, the C family of programming languages doesn’t ensure safe use of memory, which leads to the majority of all zero-day browser security bugs. Second, current engines were originally designed for use on a PC, and are challenging to scale down to low memory and low power devices. Finally, as the web platform has evolved, the tightly-coupled design of current browser engines has made it difficult to provide performance guarantees, such as 60 fps screen updates. Memory Safety Investigations have […]

    Read More