Tom Roche shared items on The Old Reader (RSS)

Read all your favorite online content in one place. Import your subscriptions in one click, find your friends, and start sharing.

Tom Roche shared items on The Old Reader (RSS) is a general podcast hosted by Unknown Host, with 50 episodes on record and a Required Pod Score of 80. PitchCentric scores this show on Booking Probability, Listen Score, and live audience signals refreshed every 24 hours.

Unknown Host hosts Tom Roche shared items on The Old Reader (RSS), a general show with 50 episodes published.

Our AI reads these to draft pitches. Use them as grounding for a pitch that cites a real guest and a specific topic.

• Tom Roche shared items on The Old Reader (RSS)

  Radio War Nerd EP 630 — Soviet-Finnish Wars, Pt. 1: Introduction + Nuclear Bunker Busters, feat. Annibale

  Aug 23, 2026—

  Co-hosts John Dolan & Mark Ames

  ListenShow Notes
• Tom Roche shared items on The Old Reader (RSS)

  Monadic Sheep: An Introduction to Canvas in GNU Emacs

  Aug 23, 2026—

  by Divya 2026 August 23 emacs canvas Bad apple playing on the top right, a 2d rainbow growing box on the left. The bottom contains: dots 3d demo, pendulum, a bouncing ball. Table of Contents 1. Frequently Asked Questions 2. What Is a Canvas? 3. Creating and Using A Canvas 3.1. Canvas via Emacs Lisp Only 3.2. Canvas via Dynamic Modules 4. Demonstrations 4.1. A Bouncing Ball 4.2. Chaotic Double Pendulum 4.3. Points in 3D Space 5. Conclusion & Further Work 6. Canvas Applications & Resources The canvas patch has been finally merged to upstream GNU Emacs. If you have been following my Mastodon , this was a journey that took us ~8 months. But finally we have, in core Emacs, a feature that I desperately desired in early 2025 when I was starting the Emacs Reader project: a way to update and manipulate images in Emacs without choking Emacs by putting the image data in strings. I went through a series of different hacks to overcome these limitations, some more successful than others, but thanks to the magnificent Daniel (aka minad) who suggested the idea of exposing a pixel buffer from within Emacs via the dynamic module API. That idea is now a feature in Emacs, and will be part of Emacs 32 release cycle. A more detailed history about this will be written later, for now this article is an introduction to the new feature, its API and what you can do using it. I will try to keep it as self-contained as I can, so that beginners are able to understand it. But first, we need to clarify certain misconceptions that people might have about this feature. 1. Frequently Asked Questions “Is this related to HTML5 Canvas ?” No. It has nothing to do with any web framework or technology. We call it “canvas” because it allows the user to draw arbitrarily on to a surface in an Emacs buffer. So at a high-level, both the HTML5 and Emacs canvas do the same thing, but they have zero relation in their implementation or how they work. HTML5 Canvas also has a more rich API with drawing functions and such, right now Emacs’ canvas API integrates with the existing image API and just provides access to the underlying pixel buffer via dynamic module API. See Canvas via Dynamic Modules . “How is this different from SVG that Emacs has support for since a long time?” Good question! So, at the level of an Emacs buffer the canvas looks and behaves just like any other Emacs image, including SVGs. Where it differs from SVG and other images is: a canvas’ :data is just ARGB32 pixel data (in strings or vectors), so no specific compressed format. the ability to access an Emacs Lisp image object from a lower level and be able to manipulate it update the image without having to call a full redisplay “Isn’t this still limited by Emacs’ redisplay engine?” Not entirely. We have a function called canvas-refresh that is to be called every time you wish to update the canvas, and this function doesn’t use/call Emacs’ redisplay , it has its own redrawing path that only updates the specific glyphs in the buffer that pertain to that canvas. Thus, whereas a full redisplay would cost more because it will try to update all the glyphs that changed, canvas-refresh only updates what needs to be. Since Emacs 25 we have double-buffering so if that’s enabled in the frame you’d still need to call redisplay to flip the buffers, but that won’t slow down your canvas. If you’re not convinced, see the demos below that run smooth at 25, 30, and 60FPS without causing any lag to the rest of the Emacs session. Or, look at this where I display a 2K60 FPS and a 720p 30FPS video side by side without Emacs missing a beat! “Is this hardware-accelerated? If not, why are you not using the GPU for this?” Because we simply don’t need it :D! A canvas simply exposes a pixel buffer, and Emacs simply redisplays it as it changes. You can get your pixels hardware accelerated outside of Emacs if you wish to, and then put them in canvas’ pixel buffer. This will give you hardware acceleration where you need it the most, pixel calculation, texture math, etc. Ideally, an introduction of a GPU powered redisplay within Emacs itself would be great and certainly help but one can still reap much of the benefits of HW acceleration from current Emacs via canvas. 2. What Is a Canvas? Before answering that question, we should ask: “what is an image in GNU Emacs?” Everybody has seen Emacs display dazzling images since decades, and of varying formats. How does Emacs do that? Well, at the level of an Emacs buffer we have something called Text Properties (also see Overlay Properties ), as its name suggests it is a property list (aka plist) for a character position or a string within a buffer. Among the many properties a text can have, there’s a special one called the display property . This special property is responsible for how the text gets displayed. This is exactly what we use to display images! You use create-image to create an image object, which is exactly a plist, and then you set this image object (called an image specification ) to be the display property of some text or overlay (which are like text properties but without the "text", it’s an object that belongs to a particular buffer with specific beginning and end and along with properties just like for usual text). This is briefly how the API of how images work in GNU Emacs. The new canvas feature works in full compatibility with this API. In short, at the level of an Emacs buffer, a canvas is just another image type! Indeed, compiling the latest GNU Emacs from source and evaluating: (image-type-available-p 'canvas) should return a t . The immediate question then is: if Emacs already supported images, and if canvas just follows the same API, then what was the point of it? Why have a new image type, when we have XBM, PPM, PNG, GIF, SVG, etc.? Well, the two-fold short answer is: You need to pass image data via strings to create these objects and for most of the above formats it’s expensive to do so (except SVGs) Any arbitrary external image data cannot be directly displayed without throttling Emacs strings or objects, etc. (i.e., there’s no low-level access to the image data) With SVGs you can mostly do really good things as long as they are simple enough, the moment you lead to have complex graphics at high refresh rate, Emacs starts throttling. I wanted in 2025 was exactly a way around this, a way to access the image Emacs is displaying at pixel-level so that I can update it in-place by fiddling with the pixels without having to pass strings or Emacs Lisp objects through the garbage collector. And this is what a canvas provides. So, there are two levels at which a canvas can be viewed and used: purely from Emacs Lisp as an image object as an ARGB32 pixel buffer via dynamic module API This allows for full integration with the existing Image API of Emacs while not sacrificing on low-level efficiency of being able to manipulate the pixel buffer directly. Now I will demonstrate how one can use the canvas in these two ways separately and/or simultaneously. 3. Creating and Using A Canvas 3.1. Canvas via Emacs Lisp Only Like usual Emacs images, one can create images either by using create-image or manually building the image spec plist. For a canvas, the latter approach would look like this: (setq test-canvas `(image :type canvas :id test :data-width 10 :data-height 10 :data nil)) This is what a canvas image’s specification looks like, the only difference between this and other images (other than the obvious :type canvas ) is that canvas images need an :id property, this is used to uniquely identify each canvas. If you used instead: (setq test-canvas (create-image nil 'canvas t)) to create the canvas, it would look almost the same: (image :type canvas :data nil :scale default :id g138) Since, of course, we didn’t provide any data in either of the cases, they are not technically valid canvas images, but that is how it looks like. To make things more interesting, remember that the "data" that a canvas accepts is ARGB32 pixel arrays. This can be done via Emacs Lisp through either unibyte strings or vectors. The latter is a bit easier to showcase, so I will go continue with that. First, let’s create our array of pixels. We use make-vector : ;; A red square of 10x0 size (setq rect-vec (make-vector (* 10 10) #xFFFF0000)) This creates a vector of 10x10 size containing each element as #xFFFF0000 (red) 32-bit ARGB pixel. It’s literally an pixel by pixel array vector that contains the color red. This is valid data for our canvas, we can now create it manually: (setq rect-canvas `(image :type canvas :id rect :data-width 10 :data-height 10 :data ,rect-vec)) Now we can simply display this: (insert (propertize "#" 'display rect-canvas)) After evaluating the above, you’ll see a tiny red square in your buffer! Voila, we now have a small canvas! 3.1.1. Note on Canvas Refresh This might not seem too useful, because you can make a small rectangle via SVGs much quickly. The real value of canvas arises with the use of canvas-refresh function using which you can update the canvas without requiring a full redisplay. It only touches the glyphs which cover the particular canvas and updates them immediately. This is significantly cheaper than calling a full redisplay that will try to update all the changes. Also, canvas-refresh has an additional optional argument RELOAD-DATA which if non- nil will reload any new updated data (either via the :data property or change in :file ) from the canvas. It will be demonstrated later how to use this function properly. 3.2. Canvas via Dynamic Modules As suggested in the introduction, canvases can be used either via Emacs Lisp and/or via dynamic modules. To know more about dynamic modules in Emacs and how to use them effectively, please consult my previous article on it. Emacs 32 provides a simple API for dealing with canvases from dynamic modules. The idea is simple, once a canvas has been created you can simply call the canavs_data function on it and it will provide you with the pixel buffer associated with the canvas. Once again, this buffer is only valid for ARGB32 pixel data. static emacs_value Fcanvas_update(emacs_env* env, ptrdiff_t nargs, emacs_value args[], void* data) { emacs_value canvas = env->args[0]; uint32_t *canvas_pixel = env->canvas_data(env, canvas); // accessing canvas' pixel buffer if (canvas_pixel) { // do some pixel manipulation to the canvas pixel } } env->funcall(env, env->intern(env, "canvas-refresh"), (emacs_value[])[rect_canvas, Qnil]); The above dynamic module function, when embedded in a legitimate dynamic module, compiled and loaded via module-load , would result in updating the canvas repeatedly by changing the colors (or whatever the pixel manipulation code does). This is how we can surpass Emacs Lisp’s limitations by accessing a low-level representation of the canvas we can manipulate directly. And since canvas-refresh avoids throttling Emacs’ full redisplay we do not encounter any slowness at all! And since we don’t use :data via Emacs Lisp image spec, whenever canvas is used via dynamic modules the RELOAD-DATA argument of canvas-refresh is to be nil . 4. Demonstrations Here we showcase a few neat graphical animations you can do with canvas, both in Emacs Lisp and dynamic modules. For our previous demonstrations, consult Tushar’s blog post where he collects all of the experiments I did with and without Emacs. Also, look at the Minad's emacs-canvas-patch which has some basic demos (including a fancy mode-line one!). The first two of the demos below would be purely in Emacs Lisp and the last one would be in C via a dynamic module. 4.1. A Bouncing Ball Let’s start with creating and setting up our canvas. We’ll go with dark violet ( #xFF8B00FF ) for the background: (setq W 250 H 250 BG #xFF8B00FF) (setq ball-canvas-vec (make-vector (* W H) BG)) (setq ball-canvas `(image :type canvas :id rect :data-width ,W :data-height ,H :data ,ball-canvas-vec)) (insert (propertize "#" 'display ball-canvas)) This is exactly what we did in the previous section, just in violet! Now is the interesting part, we want this 250x250 pixel canvas to have a ball bouncing. Well, first we prepare the ball, it will have some radius, an initial position and some initial velocity (and color!): (setq ball-radius 10) (setq bx (/ W 2) by (/ H 2)) ; start from the center (setq dx 4 dy 3) ; initial velocity (setq ball-color #xFFFFFF00) ; yellow Now we need to actually draw the ball, now I will ask you to remind yourself of some analytical geometry for this! The way we draw the ball is we take a point to be the center of the circle and check if we can build a circle around a certain bounding box. If ball-radius is 15, thus the diameter is 30, so we need at least a 30x30 square to fit the circle. Now to draw the actual circle, we’ll use the equation for a circle: x 2 + y 2 ≤ r 2 superscript 2 superscript 2 superscript 2 x^{2}+y^{2}\leq r^{2} Putting this in Emacs Lisp, we get: (defun draw-ball (cx cy color) (let ((r2 (* ball-radius ball-radius))) ; Radius squared ;; the nested loop checks for the circle within the square (dotimes (y-off (1+ (* 2 ball-radius))) (dotimes (x-off (1+ (* 2 ball-radius))) (let* ((px (+ cx (- x-off ball-radius))) (py (+ cy (- y-off ball-radius))) (dx-local (- px cx)) ; Horizontal distance from center (dy-local (- py cy)) ; Vertical distance from center (dist2 (+ (* dx-local dx-local) (* dy-local dy-local)))) ; squared distance using pythagorean theorem ;; check if pixel is inside the circle AND inside the canvas bounds (when (and (>= px 0) ( = py 0) ( The above function should make sense, while it is not the most efficient way to draw a ball, it’s relatively simple enough for the demonstration. Now we simply need to check the physics for making sure it stays within the canvas: (defun ball-bounce () (setq bx (+ bx dx) by (+ by dy)) ;; compare with ball-radius so the *edge* of the circle bounces, not the center. (when ( = bx (- W ball-radius)) (setq dx (- (abs dx))) (setq bx (- W ball-radius))) (when ( = by (- H ball-radius)) (setq dy (- (abs dy))) (setq by (- H ball-radius)))) And now we simply do it in a loop! (setq ball-frame 0) (setq max-ball-frames 2000) (defun ball-loop () (if (>= ball-frame max-ball-frames) (cancel-timer ball-timer) (setq ball-frame (1+ ball-frame)) (draw-ball bx by BG) ; make old ball invisible (turn it into background color) (ball-bounce) (draw-ball bx by ball-color) (canvas-refresh ball-canvas t))) (setq ball-timer (run-with-timer 0 0.02 'ball-loop)) Evaluate it all and you would have a yellow ball bouncing inside a violet square. It automatically stops after 2000 frames, but you can have it go on indefinitely as well! Here’s what it will look like: Yellow ball bouncing inside a violet canvas. 4.2. Chaotic Double Pendulum Now obviously I can’t go over all the math in detail, if you’re interested I’ll refer the reader to the classic Goldstein, Poole & Sako’s Classical Mechanics or Landau & Lifshitz’s Course of Theoretical Physics, Vol. I . But since you, the reader, are likely a Lisper, a better book would be Sussman & Wisdom’s Structure and Interpretation of Classical Mechanics . One of the things that fascinated me when I was studying classical mechanics for the first time was the double pendulum . The math underlying this: the Euler-Lagrange equation and variational calculus in general was also very fascinating to me. If you think it’s not, I suggest you look into the history and math behind the Brachistochrone curve . It’s evident from all this, that I want to put this into visualization using canvas! The two equations in Lagrangians which describes the chaotic system: θ ¨ 1 = − m 2 ⁢ cos ⁡ ( θ 1 − θ 2 ) ⁢ l 1 ⁢ θ ˙ 1 2 ⁢ sin ⁡ ( θ 1 − θ 2 ) + m 2 ⁢ cos ⁡ ( θ 1 − θ 2 ) ⁢ g ⁢ sin ⁡ ( θ 2 ) − m 2 ⁢ l 2 ⁢ θ ˙ 2 2 ⁢ sin ⁡ ( θ 1 − θ 2 ) − ( m 1 + m 2 ) ⁢ g ⁢ sin ⁡ ( θ 1 ) l 1 ⁢ ( m 1 + m 2 − m 2 ⁢ cos 2 ⁡ ( θ 1 − θ 2 ) ) subscript ¨ 1 subscript 2 subscript 1 subscript 2 subscript 1 superscript subscript ˙ 1 2 subscript 1 subscript 2 subscript 2 subscript 1 subscript 2 subscript 2 subscript 2 subscript 2 superscript subscript ˙ 2 2 subscript 1 subscript 2 subscript 1 subscript 2 subscript 1 subscript 1 subscript 1 subscript 2 subscript 2 superscript 2 subscript 1 subscript 2 \displaystyle\ddot{\theta}_{1}=\frac{-m_{2}\cos(\theta_{1}-\theta_{2})\,l_{1}% \dot{\theta}_{1}^{2}\sin(\theta_{1}-\theta_{2})+m_{2}\cos(\theta_{1}-\theta_{2% })\,g\sin(\theta_{2})-m_{2}l_{2}\dot{\theta}_{2}^{2}\sin(\theta_{1}-\theta_{2}% )-(m_{1}+m_{2})g\sin(\theta_{1})}{l_{1}\left(m_{1}+m_{2}-m_{2}\cos^{2}(\theta_% {1}-\theta_{2})\right)} θ ¨ 2 = ( m 1 + m 2 ) ⁢ ( l 1 ⁢ θ ˙ 1 2 ⁢ sin ⁡ ( θ 1 − θ 2 ) + θ ˙ 2 2 ⁢ sin ⁡ ( θ 1 − θ 2 ) ⁢ cos ⁡ ( θ 1 − θ 2 ) ⁢ m 2 ⁢ l 2 m 1 + m 2 + cos ⁡ ( θ 1 − θ 2 ) ⁢ g ⁢ sin ⁡ ( θ 1 ) − g ⁢ sin ⁡ ( θ 2 ) ) l 2 ⁢ ( m 1 + m 2 ⁢ sin 2 ⁡ ( θ 1 − θ 2 ) ) subscript ¨ 2 subscript 1 subscript 2 subscript 1 superscript subscript ˙ 1 2 subscript 1 subscript 2 superscript subscript ˙ 2 2 subscript 1 subscript 2 subscript 1 subscript 2 subscript 2 subscript 2 subscript 1 subscript 2 subscript 1 subscript 2 subscript 1 subscript 2 subscript 2 subscript 1 subscript 2 superscript 2 subscript 1 subscript 2 \displaystyle\ddot{\theta}_{2}=\frac{(m_{1}+m_{2})\left(l_{1}\dot{\theta}_{1}^% {2}\sin(\theta_{1}-\theta_{2})+\dfrac{\dot{\theta}_{2}^{2}\sin(\theta_{1}-% \theta_{2})\cos(\theta_{1}-\theta_{2})\,m_{2}l_{2}}{m_{1}+m_{2}}+\cos(\theta_{% 1}-\theta_{2})\,g\sin(\theta_{1})-g\sin(\theta_{2})\right)}{l_{2}\left(m_{1}+m% _{2}\sin^{2}(\theta_{1}-\theta_{2})\right)} Now let’s create the canvas as usual with black background and display it like before: (setq W 250 H 250 BG #xFF101010) (setq canvas-vec (make-vector (* W H) BG)) (setq canvas `(image :type canvas :id dp :data-width ,W :data-height ,H :data ,canvas-vec)) (insert (propertize "#" 'display canvas)) We set some constants: gravity, length of rods, and delta time: (setq g 9.8 L 60.0 dt 0.05) We set some initial conditions for the angles θ 1 subscript 1 \theta_{1} and θ 2 subscript 2 \theta_{2} ; angular velocities w 1 subscript 1 w_{1} and w 2 subscript 2 w_{2} , and a fixedd anchor point: (setq th1 2.5 th2 2.5 w1 0.0 w2 0.0) (setq pivot-x 125 pivot-y 80) We need some helpers, we already have the ball one from before and one for drawing a line/rod and to set a pixel in the vector: (defun set-px (x y color) (when (and (>= x 0) ( = y 0) ( e2 (- dy)) (setq err (- err dy)) (setq x0 (+ x0 sx))) (when ( And now the main procedure that takes care of the pendulum movment: (defun pendulum-physics () (let* ((dth (- th1 th2)) (den (- 3.0 (cos (* 2.0 dth)))) (num1 (+ (* (- g) 3.0 (sin th1)) (* (- g) (sin (- th1 (* 2.0 th2)))) (* (- 2.0) (sin dth) (+ (* w2 w2 L) (* w1 w1 L (cos dth)))))) (a1 (/ num1 (* L den))) (num2 (* 2.0 (sin dth) (+ (* 2.0 w1 w1 L) (* 2.0 g (cos th1)) (* w2 w2 L (cos dth))))) (a2 (/ num2 (* L den)))) (setq w1 (+ w1 (* a1 dt)) w2 (+ w2 (* a2 dt))) (setq th1 (+ th1 (* w1 dt)) th2 (+ th2 (* w2 dt))))) The exercise is left to the reader to make sure the above code follows the math! Specifically compare the two equations we introduced initially with the above procedure. And now the main game loop: (defun pendulum-loop () (dotimes (i 12) (pendulum-physics)) (fillarray canvas-vec BG) (let* ((x1 (+ pivot-x (* L (sin th1)))) (y1 (+ pivot-y (* L (cos th1)))) (x2 (+ x1 (* L (sin th2)))) (y2 (+ y1 (* L (cos th2))))) (draw-line pivot-x pivot-y x1 y1 #xFF888888) (draw-line x1 y1 x2 y2 #xFF888888) (draw-circ x1 y1 8 #xFF00FF00) (draw-circ x2 y2 8 #xFFFF0000) (set-px pivot-x pivot-y #xFFFFFFFF)) (canvas-refresh canvas t)) (setq my-timer (run-with-timer 0 0.05 'pendulum-loop)) And once evaluated, it will look something like this: A chaotic double pendulum rendered inside Emacs canvas at 20FPS One can enable interactivity here by making the mouse be able to drag the pendulum and set the initial positions, this is very much doable by using Emacs’ track-mouse functionality.

  ListenShow Notes
• Tom Roche shared items on The Old Reader (RSS)

  The People Have Spoken Ep1. Andy Cool'em Down'em

  Aug 21, 2026—

  It's time for the people to speak. Taking on the headlines, Ian Smith is joined by Maisie Adam and Alasdair-Beckett King to work out what is going on, and together with our audience, solve the biggest problem facing the world right now. Is Gianni Infantino just misunderstood? What kind of novelty candidate would you inhabit to capture the nation's imagination? and what small inconvenience should Andy Burnham fix next? Written by Ian Smith, Cameron Loxdale, Angela Channel and Alex Kealy Production coordinator: Asha Osborne-Grinter Recorded by David and Luca Thomas Edited by David Thomas Exec Producer: Pete Strauss Produced by Gwyn Rhys Davies. A BBC Studios Production

  ListenShow Notes
• Tom Roche shared items on The Old Reader (RSS)

  Democracy Now! 2026-08-21 Friday

  Aug 21, 2026—

  Democracy Now! 2026-08-21 Friday Headlines for August 21, 2026 As Pressure Grows, Israel Finally Opens Probe into 2024 Killing of 5-Year-Old Hind Rajab in Gaza Meet Loui Ridi: Palestinian American Returns to West Bank Home Besieged by Israeli Settlers How Trump Admin Weaponized "Antisemitism" Probes to Dismantle Higher Education "Brick by Brick" Download this show

  ListenShow Notes
• Tom Roche shared items on The Old Reader (RSS)

  8/20/26: Trump Bond Crisis Worsens, North Korea Humiliates Trump With Missile Launch

  Aug 20, 2026—

  Krystal and Saagar discuss Trump's bond crisis worsens, North Korea humiliates Trump. Sal Mercogliano: https://www.youtube.com/@wgowshipping/videos To become a Breaking Points Premium Member and watch/listen to the show AD FREE, uncut and 1 hour early visit: www.breakingpoints.com Merch Store: https://shop.breakingpoints.com/ See omnystudio.com/listener for privacy information.

  ListenShow Notes

Recent guests on Tom Roche shared items on The Old Reader (RSS). Study who booked and why before you pitch.

Based on semantic analysis of episode topics and host coverage, this show is a strong guest fit for executives in:

Industry fit is computed by PitchCentric using vector embeddings of the show's episode catalog.