diff --git a/sdl/sdl-display.cpp b/sdl/sdl-display.cpp
index 58c341f..9fc2793 100644
--- a/sdl/sdl-display.cpp
+++ b/sdl/sdl-display.cpp
@@ -9,8 +9,8 @@
 
 #include "apple/appleui.h"
 
-#define SCREENINSET_X (18*2)
-#define SCREENINSET_Y (13*2)
+#define SCREENINSET_X (18*SDLDISPLAY_SCALE)
+#define SCREENINSET_Y (13*SDLDISPLAY_SCALE)
 
 // RGB map of each of the lowres colors
 const uint8_t loresPixelColors[16][3] = { { 0, 0, 0 }, // black
@@ -85,8 +85,8 @@ void SDLDisplay::drawImageOfSizeAt(const uint8_t *img,
     for (uint16_t x=0; x<sizex; x++) {
       const uint8_t *p = &img[(y * sizex + x)*3];
       p = &img[(y * sizex + x)*3];
-      drawPixel((x+wherex)*2, y+wherey, p[0], p[1], p[2]);
-      drawPixel((x+wherex)*2+1, y+wherey, p[0], p[1], p[2]);
+      drawPixel((x+wherex)*SDLDISPLAY_SCALE, y+wherey, p[0], p[1], p[2]);
+      drawPixel((x+wherex)*SDLDISPLAY_SCALE+1, y+wherey, p[0], p[1], p[2]);
     }
   }
 }
@@ -103,8 +103,8 @@ void SDLDisplay::blit(AiieRect r)
   // not the border. We don't support updating the border *except* by
   // drawing directly to the screen device...
 
-  for (uint16_t y=r.top*2; y<r.bottom*2; y++) {
-    for (uint16_t x=r.left*2; x<r.right*2; x++) {
+  for (uint16_t y=r.top*SDLDISPLAY_SCALE; y<r.bottom*SDLDISPLAY_SCALE; y++) {
+    for (uint16_t x=r.left*SDLDISPLAY_SCALE; x<r.right*SDLDISPLAY_SCALE; x++) {
       uint8_t colorIdx = videoBuffer[y*SDLDISPLAY_WIDTH+x];
 
       uint8_t r, g, b;
@@ -142,8 +142,7 @@ inline void putpixel(SDL_Renderer *renderer, int x, int y, uint8_t r, uint8_t g,
 
 void SDLDisplay::drawUIPixel(uint16_t x, uint16_t y, uint16_t color)
 {
-  drawPixel(x*2, y, color);
-  drawPixel(x*2+1, y, color);
+  drawPixel(x*SDLDISPLAY_SCALE, y, color);
 }
 
 void SDLDisplay::drawPixel(uint16_t x, uint16_t y, uint16_t color)
@@ -154,17 +153,21 @@ void SDLDisplay::drawPixel(uint16_t x, uint16_t y, uint16_t color)
     b = (color & 0x1F) << 3;
 
 
-  // Pixel-doubling vertically
-  for (int yoff=0; yoff<2; yoff++) {
-    putpixel(renderer, x, yoff+y*2, r, g, b);
+  // Pixel-doubling vertically and horizontally, based on scale
+  for (int yoff=0; yoff<SDLDISPLAY_SCALE; yoff++) {
+    for (int xoff=0; xoff<SDLDISPLAY_SCALE; xoff++) {
+      putpixel(renderer, x+xoff, yoff+y*SDLDISPLAY_SCALE, r, g, b);
+    }
   }
 }
 
 void SDLDisplay::drawPixel(uint16_t x, uint16_t y, uint8_t r, uint8_t g, uint8_t b)
 {
-  // Pixel-doubling vertically
-  for (int yoff=0; yoff<2; yoff++) {
-    putpixel(renderer, x, yoff+y*2, r, g, b);
+  // Pixel-doubling horizontally and vertically, based on scale
+  for (int yoff=0; yoff<SDLDISPLAY_SCALE; yoff++) {
+    for (int xoff=0; xoff<SDLDISPLAY_SCALE; xoff++) {
+      putpixel(renderer, x+xoff, yoff+y*SDLDISPLAY_SCALE, r, g, b);
+    }
   }
 }
 
@@ -230,35 +233,63 @@ void SDLDisplay::clrScr()
   SDL_RenderPresent(renderer); // perform the render
 }
 
+// This was called with the expectation that it can draw every one of
+// the 560x192 pixels that could be addressed. The SDLDISPLAY_SCALE is
+// basically half the X scale - so a 320-pixel-wide screen can show 40
+// columns fine, which means that we need to be creative for 80 columns,
+// which need to be alpha-blended...
 void SDLDisplay::cachePixel(uint16_t x, uint16_t y, uint8_t color)
 {
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x] = color;
-  videoBuffer[((y*2)+1)*SDLDISPLAY_WIDTH+x] = color;
+  if (SDLDISPLAY_SCALE == 1) {
+    // we need to alpha blend the X because there aren't enough screen pixels.
+    // This takes advantage of the fact that we always call this linearly
+    // for the 80-column text -- we never (?) do partial screen blits, but
+    // always wind up redrawing the entirety. So we can look at the pixel in
+    // the "shared" cell of RAM, and come up with a color between the two.
+    if (x&1) {
+      uint8_t origColor = videoBuffer[(y*SDLDISPLAY_SCALE)*SDLDISPLAY_WIDTH+(x>>1)*SDLDISPLAY_SCALE];
+
+      uint8_t newColor = (uint16_t) (origColor + color) / 2;
+
+      if (x==1 && y==0) {
+	printf("origcolor: %d color: %d newcolor: %d\n", origColor, color, newColor);
+      }
+      cacheDoubleWidePixel(x>>1,y,newColor);
+      // Else if it's black, we leave whatever was in the other pixel.
+    } else {
+      // The even pixels always draw.
+      cacheDoubleWidePixel(x>>1,y,color);
+    }
+    
+  } else {
+    // we have enough resolution to show all the pixels, so just do it
+    x = (x * SDLDISPLAY_SCALE)/2;
+    for (int yoff=0; yoff<SDLDISPLAY_SCALE; yoff++) {
+      for (int xoff=0; xoff<SDLDISPLAY_SCALE; xoff++) {
+	videoBuffer[(y*SDLDISPLAY_SCALE+yoff)*SDLDISPLAY_WIDTH+x+xoff] = color;
+      }
+    }
+  }
 }
 
 // "DoubleWide" means "please double the X because I'm in low-res width mode"
 void SDLDisplay::cacheDoubleWidePixel(uint16_t x, uint16_t y, uint8_t color)
 {
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2] = color;
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2+1] = color;
-
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2] = color;
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2+1] = color;
+  for (int yoff=0; yoff<SDLDISPLAY_SCALE; yoff++) {
+    for (int xoff=0; xoff<SDLDISPLAY_SCALE; xoff++) {
+      videoBuffer[(y*SDLDISPLAY_SCALE+yoff)*SDLDISPLAY_WIDTH+x*SDLDISPLAY_SCALE+xoff] = color;
+    }
+  }
 }
 
 void SDLDisplay::cache2DoubleWidePixels(uint16_t x, uint16_t y, uint8_t colorB, uint8_t colorA)
 {
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2] = colorA;
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2+1] = colorA;
-
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2+2] = colorB;
-  videoBuffer[y*2*SDLDISPLAY_WIDTH+x*2+3] = colorB;
-
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2] = colorA;
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2+1] = colorA;
-
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2+2] = colorB;
-  videoBuffer[(y*2+1)*SDLDISPLAY_WIDTH+x*2+3] = colorB;
+  for (int yoff=0; yoff<SDLDISPLAY_SCALE; yoff++) {
+    for (int xoff=0; xoff<SDLDISPLAY_SCALE; xoff++) {
+      videoBuffer[(y*SDLDISPLAY_SCALE+yoff)*SDLDISPLAY_WIDTH+x*SDLDISPLAY_SCALE+2*xoff] = colorA;
+      videoBuffer[(y*SDLDISPLAY_SCALE+yoff)*SDLDISPLAY_WIDTH+x*SDLDISPLAY_SCALE+1+2*xoff] = colorB;
+    }
+  }
 }
 
 
diff --git a/sdl/sdl-display.h b/sdl/sdl-display.h
index 78640c7..475c6db 100644
--- a/sdl/sdl-display.h
+++ b/sdl/sdl-display.h
@@ -8,9 +8,11 @@
 
 #include "physicaldisplay.h"
 
-
-#define SDLDISPLAY_WIDTH (320*2)
-#define SDLDISPLAY_HEIGHT (240*2)
+// scale can be 1,2,4. '1' is half-width at the highest resolution
+// (80-col mode). '2' is full width. '4' is double full width.
+#define SDLDISPLAY_SCALE 1
+#define SDLDISPLAY_WIDTH (320*SDLDISPLAY_SCALE)
+#define SDLDISPLAY_HEIGHT (240*SDLDISPLAY_SCALE)
 
 class SDLDisplay : public PhysicalDisplay {
  public:
diff --git a/teensy/teensy-display.cpp b/teensy/teensy-display.cpp
index 34911ae..adbefe2 100644
--- a/teensy/teensy-display.cpp
+++ b/teensy/teensy-display.cpp
@@ -32,6 +32,9 @@
 volatile DMAMEM uint16_t dmaBuffer[240][320]; // 240 rows, 320 columns
 
 #define RGBto565(r,g,b) ((((r) & 0xF8) << 8) | (((g) & 0xFC) << 3) | ((b) >> 3))
+#define _565toR(c) ( ((c) & 0xF800) >> 8 )
+#define _565toG(c) ( ((c) & 0x07E0) >> 5 )
+#define _565toB(c) ( ((c) & 0x001F) )
 
 ILI9341_t3 tft = ILI9341_t3(PIN_CS, PIN_DC, PIN_RST, PIN_MOSI, PIN_SCK, PIN_MISO);
 
@@ -302,26 +305,79 @@ void TeensyDisplay::cache2DoubleWidePixels(uint16_t x, uint16_t y,
   dmaBuffer[y+VOFFSET][x+1+HOFFSET] = loresPixelColors[colorA&0xF];
 }
 
+inline double logfn(double x)
+{
+  // At a value of x=255, log(base 1.022)(x) is 254.636.
+  return log(x)/log(1.022);
+}
+  
+
+inline uint16_t blendColors(uint16_t a, uint16_t b)
+{
+  // Straight linear average doesn't work well for inverted text, because the
+  // whites overwhelm the blacks.
+  //return ((uint32_t)a + (uint32_t)b)/2;
+
+#if 0
+  // Testing a logarithmic color scale. My theory was that, since our
+  // colors here are mostly black or white, it would be reasonable to
+  // use a log scale of the average to bump up the brightness a
+  // little. In practice, it's not really legible.
+  return RGBto565(  (uint8_t)(logfn((_565toR(a) + _565toR(b))/2)),
+		    (uint8_t)(logfn((_565toG(a) + _565toG(b))/2)),
+		    (uint8_t)(logfn((_565toB(a) + _565toB(b))/2))  );
+#endif
+  
+  // Doing an R/G/B average works okay for legibility. It's not great for
+  // inverted text.
+  return RGBto565(  (_565toR(a) + _565toR(b))/2,
+		    (_565toG(a) + _565toG(b))/2,
+		    (_565toB(a) + _565toB(b))/2  );
+
+}
+
 // This is the full 560-pixel-wide version -- and we only have 280
 // pixels in our buffer b/c the display is only 320 pixels wide
 // itself. So we'll divide x by 2. On odd-numbered X pixels, we also
-// alpha-blend -- "black" means "clear"
+// blend the colors of the two virtual pixels that share an onscreen
+// pixel
 void TeensyDisplay::cachePixel(uint16_t x, uint16_t y, uint8_t color)
 {
-  if (/*x&*/1) {
-    // divide x by 2, then this is mostly cacheDoubleWidePixel. Except
-    // we also have to do the alpha blend so we can see both pixels.
-    
-    uint16_t *p = &dmaBuffer[y+VOFFSET][(x>>1)+HOFFSET];
-    uint16_t destColor = loresPixelColors[color];
-    
-    //    if (color == 0)
-    //      destColor = *p; // retain the even-numbered pixel's contents ("alpha blend")
-    // Otherwise the odd-numbered pixel's contents "win" as "last drawn"
-    // FIXME: do better blending of these two pixels.
-    
-    dmaBuffer[y+VOFFSET][(x>>1)+HOFFSET] = destColor;
+#if 0
+  static uint8_t previousColor = 0;
+#endif
+  if (x&1) {
+    // Blend the two pixels. This takes advantage of the fact that we
+    // always call this linearly for 80-column text drawing -- we never
+    // do partial screen blits, but always draw at least a whole character.
+    // So we can look at the pixel in the "shared" cell of RAM, and come up
+    // with a color between the two.
+
+#if 1
+    // This is straight blending, R/G/B average
+    uint16_t origColor = dmaBuffer[y+VOFFSET][(x>>1)+HOFFSET];
+    uint16_t newColor = loresPixelColors[color];
+    cacheDoubleWidePixel(x>>1, y, blendColors(origColor, newColor));
+#endif
+
+#if 0
+  // The model we use for the SDL display works better, strangely - it keeps
+  // the lores pixel index color (black, magenda, dark blue, purple, dark
+  // green, etc.) until render time; so when it does the blend here, it's
+  // actually blending in a very nonlinear way - e.g. "black + white / 2"
+  // is actually "black(0) + white(15) / 2 = 15/2 = 7 (light blue)". Weird,
+  // but definitely legible in a mini laptop SDL window with the same scale.
+  // Unfortunately, it doesn't translate well to a ILI9341 panel; the pixels
+  // are kind of muddy and indistinct, so the blue spills over and makes it
+  // very difficult to read.
+    uint8_t origColor = previousColor;
+    uint8_t newColor = (uint16_t)(origColor + color) / 2;
+    cacheDoubleWidePixel(x>>1, y, (uint16_t)color + (uint16_t)previousColor/2);
+#endif
   } else {
-    cacheDoubleWidePixel(x, y, color);
+#if 0
+    previousColor = color; // used for blending
+#endif
+    cacheDoubleWidePixel(x>>1, y, color);
   }
 }