Add support for subpixel rendering on Linux

Author: nightuser

kitty/cell_fragment.glsl

@@ -1,8 +1,9 @@
 #version GLSL_VERSION
 #define WHICH_PROGRAM
 #define NOT_TRANSPARENT
+#define NOT_SUBPIXEL
 
-#if defined(SIMPLE) || defined(BACKGROUND) || defined(SPECIAL)
+#if defined(SIMPLE) || defined(BACKGROUND) || defined(SPECIAL) || defined(SUBPIXEL)
 #define NEEDS_BACKROUND
 #endif
 
@@ -28,6 +29,7 @@ in vec3 foreground;
 in vec4 cursor_color_vec;
 in vec3 decoration_fg;
 in float colored_sprite;
+in float subpixel;
 #endif
 
 out vec4 final_color;
@@ -56,7 +58,13 @@ vec4 alpha_blend_premul(vec3 over, float over_alpha, vec3 under, float under_alp
 #ifdef NEEDS_FOREGROUND
 vec4 calculate_foreground() {
     vec4 text_fg = texture(sprites, sprite_pos);
+#ifdef SUBPIXEL
+    vec3 unblended_fg = mix(foreground, text_fg.rgb, colored_sprite);
+    vec3 blended_fg = mix(background, unblended_fg, text_fg.rgb);
+    vec3 fg = mix(unblended_fg, blended_fg, subpixel);
+#else
     vec3 fg = mix(foreground, text_fg.rgb, colored_sprite);
+#endif
     float text_alpha = text_fg.a;
     float underline_alpha = texture(sprites, underline_pos).a;
     float strike_alpha = texture(sprites, strike_pos).a;

kitty/cell_vertex.glsl

@@ -6,6 +6,7 @@
 #define STRIKE_SHIFT {STRIKE_SHIFT}
 #define DIM_SHIFT {DIM_SHIFT}
 #define USE_SELECTION_FG
+#define NOT_SUBPIXEL
 
 // Inputs {{{
 layout(std140) uniform CellRenderData {
@@ -35,7 +36,7 @@ const uvec2 cell_pos_map[] = uvec2[4](
 // }}}
 
 
-#if defined(SIMPLE) || defined(BACKGROUND) || defined(SPECIAL)
+#if defined(SIMPLE) || defined(BACKGROUND) || defined(SPECIAL) || defined(SUBPIXEL)
 #define NEEDS_BACKROUND
 #endif
 
@@ -61,6 +62,7 @@ out vec3 strike_pos;
 out vec3 foreground;
 out vec3 decoration_fg;
 out float colored_sprite;
+out float subpixel;
 out float effective_text_alpha;
 #endif
 
@@ -69,6 +71,7 @@ out float effective_text_alpha;
 const uint BYTE_MASK = uint(0xFF);
 const uint Z_MASK = uint(0xFFF);
 const uint COLOR_MASK = uint(0x4000);
+const uint SUBPIXEL_MASK = uint(0x8000);
 const uint ZERO = uint(0);
 const uint ONE = uint(1);
 const uint TWO = uint(2);
@@ -166,6 +169,7 @@ void main() {
     // The character sprite being rendered
     sprite_pos = to_sprite_pos(pos, sprite_coords.x, sprite_coords.y, sprite_coords.z & Z_MASK);
     colored_sprite = float((sprite_coords.z & COLOR_MASK) >> 14);
+    subpixel = float((sprite_coords.z & SUBPIXEL_MASK) >> 15);
 
     // Foreground
     uint resolved_fg = resolve_color(colors[fg_index], default_colors[fg_index]);

kitty/config_data.py

@@ -941,6 +941,11 @@ def macos_option_as_alt(x):
 invisible on dual GPU machines.'''))
 # }}}
 
+o('linux_use_subpixel_rendering', False, long_text=_('''
+Use subpixel rendering instead of grayscale in freetype. Impacts performance,
+but may look better on low DPI screens.
+'''))
+
 g('shortcuts')  # {{{
 
 o('kitty_mod', 'ctrl+shift', option_type=to_modifiers, long_text=_('''

kitty/fonts.c

@@ -32,7 +32,7 @@ typedef struct {
 typedef struct SpritePosition SpritePosition;
 struct SpritePosition {
     SpritePosition *next;
-    bool filled, rendered, colored;
+    bool filled, rendered, colored, subpixel;
     sprite_index x, y, z;
     uint8_t ligature_index;
     glyph_index glyph;
@@ -247,6 +247,7 @@ sprite_position_for(FontGroup *fg, Font *font, glyph_index glyph, ExtraGlyphs *e
     s->filled = true;
     s->rendered = false;
     s->colored = false;
+    s->subpixel = false;
     s->x = fg->sprite_tracker.x; s->y = fg->sprite_tracker.y; s->z = fg->sprite_tracker.z;
     do_increment(fg, error);
     return s;
@@ -301,7 +302,7 @@ free_maps(Font *font) {
 
 void
 clear_sprite_map(Font *font) {
-#define CLEAR(s) s->filled = false; s->rendered = false; s->colored = false; s->glyph = 0; memset(&s->extra_glyphs, 0, sizeof(ExtraGlyphs)); s->x = 0; s->y = 0; s->z = 0; s->ligature_index = 0;
+#define CLEAR(s) s->filled = false; s->rendered = false; s->colored = false; s->subpixel = false; s->glyph = 0; memset(&s->extra_glyphs, 0, sizeof(ExtraGlyphs)); s->x = 0; s->y = 0; s->z = 0; s->ligature_index = 0;
     SpritePosition *s;
     for (size_t i = 0; i < sizeof(font->sprite_map)/sizeof(font->sprite_map[0]); i++) {
         s = font->sprite_map + i;
@@ -606,6 +607,7 @@ render_box_cell(FontGroup *fg, CPUCell *cpu_cell, GPUCell *gpu_cell) {
     if (sp->rendered) return;
     sp->rendered = true;
     sp->colored = false;
+    sp->subpixel = false;
     PyObject *ret = PyObject_CallFunction(box_drawing_function, "IIId", cpu_cell->ch, fg->cell_width, fg->cell_height, (fg->logical_dpi_x + fg->logical_dpi_y) / 2.0);
     if (ret == NULL) { PyErr_Print(); return; }
     uint8_t *alpha_mask = PyLong_AsVoidPtr(PyTuple_GET_ITEM(ret, 0));
@@ -640,6 +642,7 @@ static inline void
 set_cell_sprite(GPUCell *cell, SpritePosition *sp) {
     cell->sprite_x = sp->x; cell->sprite_y = sp->y; cell->sprite_z = sp->z;
     if (sp->colored) cell->sprite_z |= 0x4000;
+    if (sp->subpixel) cell->sprite_z |= 0x8000;
 }
 
 static inline pixel*
@@ -671,12 +674,14 @@ render_group(FontGroup *fg, unsigned int num_cells, unsigned int num_glyphs, CPU
 
     clear_canvas(fg);
     bool was_colored = (gpu_cells->attrs & WIDTH_MASK) == 2 && is_emoji(cpu_cells->ch);
-    render_glyphs_in_cells(font->face, font->bold, font->italic, info, positions, num_glyphs, fg->canvas, fg->cell_width, fg->cell_height, num_cells, fg->baseline, &was_colored, (FONTS_DATA_HANDLE)fg, center_glyph);
+    bool was_subpixel = false;
+    render_glyphs_in_cells(font->face, font->bold, font->italic, info, positions, num_glyphs, fg->canvas, fg->cell_width, fg->cell_height, num_cells, fg->baseline, &was_colored, &was_subpixel, (FONTS_DATA_HANDLE)fg, center_glyph);
     if (PyErr_Occurred()) PyErr_Print();
 
     for (unsigned int i = 0; i < num_cells; i++) {
         sprite_position[i]->rendered = true;
         sprite_position[i]->colored = was_colored;
+        sprite_position[i]->subpixel = was_subpixel;
         set_cell_sprite(gpu_cells + i, sprite_position[i]);
         pixel *buf = num_cells == 1 ? fg->canvas : extract_cell_from_canvas(fg, i, num_cells);
         current_send_sprite_to_gpu((FONTS_DATA_HANDLE)fg, sprite_position[i]->x, sprite_position[i]->y, sprite_position[i]->z, buf);

kitty/fonts.h

@@ -26,7 +26,7 @@ bool is_glyph_empty(PyObject *, glyph_index);
 hb_font_t* harfbuzz_font_for_face(PyObject*);
 bool set_size_for_face(PyObject*, unsigned int, bool, FONTS_DATA_HANDLE);
 void cell_metrics(PyObject*, unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*);
-bool render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *info, hb_glyph_position_t *positions, unsigned int num_glyphs, pixel *canvas, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, unsigned int baseline, bool *was_colored, FONTS_DATA_HANDLE, bool center_glyph);
+bool render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *info, hb_glyph_position_t *positions, unsigned int num_glyphs, pixel *canvas, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, unsigned int baseline, bool *was_colored, bool *was_subpixel, FONTS_DATA_HANDLE, bool center_glyph);
 PyObject* create_fallback_face(PyObject *base_face, CPUCell* cell, bool bold, bool italic, bool emoji_presentation, FONTS_DATA_HANDLE fg);
 PyObject* specialize_font_descriptor(PyObject *base_descriptor, FONTS_DATA_HANDLE);
 PyObject* face_from_path(const char *path, int index, FONTS_DATA_HANDLE);

kitty/freetype.c

@@ -10,7 +10,9 @@
 #include <math.h>
 #include <structmember.h>
 #include <ft2build.h>
+#include FT_DRIVER_H
 #include <hb-ft.h>
+#include <fontconfig/fontconfig.h>
 
 #if HB_VERSION_MAJOR > 1 || (HB_VERSION_MAJOR == 1 && (HB_VERSION_MINOR > 6 || (HB_VERSION_MINOR == 6 && HB_VERSION_MICRO >= 3)))
 #define HARFBUZZ_HAS_CHANGE_FONT
@@ -29,6 +31,7 @@ typedef struct {
     unsigned int units_per_EM;
     int ascender, descender, height, max_advance_width, max_advance_height, underline_position, underline_thickness;
     int hinting, hintstyle, index;
+    int rgba;
     bool is_scalable, has_color;
     float size_in_pts;
     FT_F26Dot6 char_width, char_height;
@@ -159,13 +162,14 @@ get_load_flags(int hinting, int hintstyle, int base) {
 
 
 static inline bool
-init_ft_face(Face *self, PyObject *path, int hinting, int hintstyle, FONTS_DATA_HANDLE fg) {
+init_ft_face(Face *self, PyObject *path, int hinting, int hintstyle, int rgba, FONTS_DATA_HANDLE fg) {
 #define CPY(n) self->n = self->face->n;
     CPY(units_per_EM); CPY(ascender); CPY(descender); CPY(height); CPY(max_advance_width); CPY(max_advance_height); CPY(underline_position); CPY(underline_thickness);
 #undef CPY
     self->is_scalable = FT_IS_SCALABLE(self->face);
     self->has_color = FT_HAS_COLOR(self->face);
     self->hinting = hinting; self->hintstyle = hintstyle;
+    self->rgba = rgba;
     if (!set_size_for_face((PyObject*)self, 0, false, fg)) return false;
     self->harfbuzz_font = hb_ft_font_create(self->face, NULL);
     if (self->harfbuzz_font == NULL) { PyErr_NoMemory(); return false; }
@@ -189,16 +193,24 @@ face_from_descriptor(PyObject *descriptor, FONTS_DATA_HANDLE fg) {
     long index = 0;
     bool hinting = false;
     long hint_style = 0;
+    long rgba = 0;
     D(path, PyUnicode_AsUTF8, false);
     D(index, PyLong_AsLong, true);
     D(hinting, PyObject_IsTrue, true);
     D(hint_style, PyLong_AsLong, true);
+    D(rgba, PyLong_AsLong, true);
 #undef D
     Face *self = (Face *)Face_Type.tp_alloc(&Face_Type, 0);
     if (self != NULL) {
         int error = FT_New_Face(library, path, index, &(self->face));
         if(error) { set_freetype_error("Failed to load face, with error:", error); Py_CLEAR(self); return NULL; }
-        if (!init_ft_face(self, PyDict_GetItemString(descriptor, "path"), hinting, hint_style, fg)) { Py_CLEAR(self); return NULL; }
+        if (!init_ft_face(self, PyDict_GetItemString(descriptor, "path"), hinting, hint_style, rgba, fg)) { Py_CLEAR(self); return NULL; }
+        FT_Parameter property_darkening;
+        FT_Bool darken_stems = 1;
+        property_darkening.tag  = FT_PARAM_TAG_STEM_DARKENING;
+        property_darkening.data = &darken_stems;
+        error = FT_Face_Properties(self->face, 1, &property_darkening);
+        if(error) { set_freetype_error("Failed to set face property, with error:", error); Py_CLEAR(self); return NULL; }
     }
     return (PyObject*)self;
 }
@@ -210,7 +222,7 @@ face_from_path(const char *path, int index, FONTS_DATA_HANDLE fg) {
     int error;
     error = FT_New_Face(library, path, index, &ans->face);
     if (error) { set_freetype_error("Failed to load face, with error:", error); ans->face = NULL; return NULL; }
-    if (!init_ft_face(ans, Py_None, true, 3, fg)) { Py_CLEAR(ans); return NULL; }
+    if (!init_ft_face(ans, Py_None, true, 3, 1, fg)) { Py_CLEAR(ans); return NULL; }
     return (PyObject*)ans;
 }
 
@@ -351,7 +363,10 @@ populate_processed_bitmap(FT_GlyphSlotRec *slot, FT_Bitmap *bitmap, ProcessedBit
 
 static inline bool
 render_bitmap(Face *self, int glyph_id, ProcessedBitmap *ans, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, bool bold, bool italic, bool rescale, FONTS_DATA_HANDLE fg) {
-    if (!load_glyph(self, glyph_id, FT_LOAD_RENDER)) return false;
+    int flags = FT_LOAD_RENDER;
+    if (OPT(linux_use_subpixel_rendering))
+      flags |= FT_LOAD_TARGET_LCD;
+    if (!load_glyph(self, glyph_id, flags)) return false;
     unsigned int max_width = cell_width * num_cells;
 
     // Embedded bitmap glyph?
@@ -372,6 +387,9 @@ render_bitmap(Face *self, int glyph_id, ProcessedBitmap *ans, unsigned int cell_
         }
         populate_processed_bitmap(self->face->glyph, &bitmap, ans, true);
         FT_Bitmap_Done(library, &bitmap);
+    } else if (self->face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD) {
+        populate_processed_bitmap(self->face->glyph, &self->face->glyph->bitmap, ans, false);
+        ans->width /= 3;
     } else {
         populate_processed_bitmap(self->face->glyph, &self->face->glyph->bitmap, ans, false);
     }
@@ -488,7 +506,24 @@ copy_color_bitmap(uint8_t *src, pixel* dest, Region *src_rect, Region *dest_rect
 }
 
 static inline void
-place_bitmap_in_canvas(pixel *cell, ProcessedBitmap *bm, size_t cell_width, size_t cell_height, float x_offset, float y_offset, size_t baseline) {
+copy_lcd_bitmap(uint8_t *src, pixel* dest, Region *src_rect, Region *dest_rect, size_t src_stride, size_t dest_stride, bool bgr) {
+    for (size_t sr = src_rect->top, dr = dest_rect->top; sr < src_rect->bottom && dr < dest_rect->bottom; sr++, dr++) {
+        pixel *d = dest + dest_stride * dr;
+        uint8_t *s = src + src_stride * sr;
+        for(size_t sc = src_rect->left, dc = dest_rect->left; sc < src_rect->right && dc < dest_rect->right; sc++, dc++) {
+            uint8_t *rgb = s + 3 * sc;
+#define C(idx, shift) ( rgb[idx] << shift)
+            if (!bgr)
+              d[dc] = C(0, 24) | C(1, 16) | C(2, 8) | 0xff;
+            else
+              d[dc] = C(2, 24) | C(1, 16) | C(0, 8) | 0xff;
+#undef C
+        }
+    }
+}
+
+static inline void
+place_bitmap_in_canvas(pixel *cell, ProcessedBitmap *bm, size_t cell_width, size_t cell_height, float x_offset, float y_offset, size_t baseline, bool bgr) {
     // We want the glyph to be positioned inside the cell based on the bearingX
     // and bearingY values, making sure that it does not overflow the cell.
 
@@ -517,13 +552,15 @@ place_bitmap_in_canvas(pixel *cell, ProcessedBitmap *bm, size_t cell_width, size
 
     if (bm->pixel_mode == FT_PIXEL_MODE_BGRA) {
         copy_color_bitmap(bm->buf, cell, &src, &dest, bm->stride, cell_width);
+    } else if (bm->pixel_mode == FT_PIXEL_MODE_LCD) {
+        copy_lcd_bitmap(bm->buf, cell, &src, &dest, bm->stride, cell_width, bgr);
     } else render_alpha_mask(bm->buf, cell, &src, &dest, bm->stride, cell_width);
 }
 
 static const ProcessedBitmap EMPTY_PBM = {.factor = 1};
 
 bool
-render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *info, hb_glyph_position_t *positions, unsigned int num_glyphs, pixel *canvas, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, unsigned int baseline, bool *was_colored, FONTS_DATA_HANDLE fg, bool center_glyph) {
+render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *info, hb_glyph_position_t *positions, unsigned int num_glyphs, pixel *canvas, unsigned int cell_width, unsigned int cell_height, unsigned int num_cells, unsigned int baseline, bool *was_colored, bool *was_subpixel, FONTS_DATA_HANDLE fg, bool center_glyph) {
     Face *self = (Face*)f;
     bool is_emoji = *was_colored; *was_colored = is_emoji && self->has_color;
     float x = 0.f, y = 0.f, x_offset = 0.f;
@@ -540,10 +577,11 @@ render_glyphs_in_cells(PyObject *f, bool bold, bool italic, hb_glyph_info_t *inf
         } else {
             if (!render_bitmap(self, info[i].codepoint, &bm, cell_width, cell_height, num_cells, bold, italic, true, fg)) return false;
         }
+        *was_subpixel = (bm.pixel_mode == FT_PIXEL_MODE_LCD);
         x_offset = x + (float)positions[i].x_offset / 64.0f;
         y = (float)positions[i].y_offset / 64.0f;
         if ((*was_colored || self->face->glyph->metrics.width > 0) && bm.width > 0) {
-            place_bitmap_in_canvas(canvas, &bm, canvas_width, cell_height, x_offset, y, baseline);
+            place_bitmap_in_canvas(canvas, &bm, canvas_width, cell_height, x_offset, y, baseline, (self->rgba == FC_RGBA_BGR));
         }
         x += (float)positions[i].x_advance / 64.0f;
         free_processed_bitmap(&bm);
@@ -591,12 +629,17 @@ render_simple_text_impl(PyObject *s, const char *text, unsigned int baseline) {
         FT_UInt glyph_index = FT_Get_Char_Index(self->face, text[n]);
         int error = FT_Load_Glyph(self->face, glyph_index, FT_LOAD_DEFAULT);
         if (error) continue;
-        error = FT_Render_Glyph(self->face->glyph, FT_RENDER_MODE_NORMAL);
+        int flags = 0;
+        if (OPT(linux_use_subpixel_rendering))
+          flags |= FT_RENDER_MODE_LCD;
+        else
+          flags |= FT_RENDER_MODE_NORMAL;
+        error = FT_Render_Glyph(self->face->glyph, flags);
         if (error) continue;
         FT_Bitmap *bitmap = &self->face->glyph->bitmap;
         pbm = EMPTY_PBM;
         populate_processed_bitmap(self->face->glyph, bitmap, &pbm, false);
-        place_bitmap_in_canvas(canvas, &pbm, canvas_width, canvas_height, pen_x, 0, baseline);
+        place_bitmap_in_canvas(canvas, &pbm, canvas_width, canvas_height, pen_x, 0, baseline, (self->rgba == FC_RGBA_BGR));
         pen_x += self->face->glyph->advance.x >> 6;
     }
     ans.width = pen_x; ans.height = canvas_height;

kitty/glfw.c

@@ -567,6 +567,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
     // blank the window once so that there is no initial flash of color
     // changing, in case the background color is not black
     blank_canvas(is_semi_transparent ? OPT(background_opacity) : 1.0f);
+    bool is_subpixel_enabled = OPT(linux_use_subpixel_rendering);
 #ifndef __APPLE__
     if (is_first_window) glfwSwapInterval(OPT(sync_to_monitor) && !global_state.is_wayland ? 1 : 0);
 #endif
@@ -579,7 +580,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args) {
         glfwShowWindow(glfw_window);
     }
     if (is_first_window) {
-        PyObject *ret = PyObject_CallFunction(load_programs, "O", is_semi_transparent ? Py_True : Py_False);
+        PyObject *ret = PyObject_CallFunction(load_programs, "OO", is_semi_transparent ? Py_True : Py_False, is_subpixel_enabled ? Py_True : Py_False);
         if (ret == NULL) return NULL;
         Py_DECREF(ret);
 #ifdef __APPLE__

kitty/main.py

@@ -82,8 +82,8 @@ def talk_to_instance(args):
         conn.close()
 
 
-def load_all_shaders(semi_transparent=0):
-    load_shader_programs(semi_transparent)
+def load_all_shaders(semi_transparent=False, subpixel_enabled=False):
+    load_shader_programs(semi_transparent, subpixel_enabled)
     load_borders_program()
 
 

kitty/state.c

@@ -408,6 +408,7 @@ PYWRAP1(set_options) {
     S(macos_window_resizable, PyObject_IsTrue);
     S(macos_hide_from_tasks, PyObject_IsTrue);
     S(macos_thicken_font, PyFloat_AsDouble);
+    S(linux_use_subpixel_rendering, PyObject_IsTrue);
     S(tab_bar_min_tabs, PyLong_AsUnsignedLong);
     S(disable_ligatures, PyLong_AsLong);
 

kitty/state.h

@@ -25,6 +25,7 @@ typedef struct {
     double repaint_delay, input_delay;
     bool focus_follows_mouse, hide_window_decorations;
     bool macos_hide_from_tasks, macos_quit_when_last_window_closed, macos_window_resizable, macos_traditional_fullscreen, macos_show_window_title_in_menubar;
+    bool linux_use_subpixel_rendering;
     unsigned int macos_option_as_alt;
     float macos_thicken_font;
     int adjust_line_height_px, adjust_column_width_px;