Emacs On Second Screen: Maximize Frames In Windows

Aug 15, 2025 by Kenji Nakamura 51 views

Emacs on Dual Monitors: Maximize Frames on Your Second Screen in Windows

Hey guys! Ever wished you could unleash the full power of Emacs across your dual monitors in Windows? It's totally doable, and I'm here to walk you through how to make it happen. Specifically, we'll focus on getting those new Emacs frames to pop up on your second screen, maximized and ready for action. No more dragging windows around – let's get efficient!

Understanding Emacs Frames and Windows

Before we dive into the code, let's clarify some Emacs terminology. In Emacs, a frame is what you'd typically think of as a window in other applications. It's the top-level container that holds everything. Inside a frame, you can have multiple windows, which are the individual areas displaying buffers (files, help text, etc.). So, when we talk about opening a new frame on the second screen, we're talking about creating a brand-new top-level window.

This distinction is crucial because Emacs's window management can seem a little different at first. You might be tempted to think about splitting an existing frame, but for our goal of using a second monitor, we want a completely independent frame.

The beauty of Emacs is its customizability. Everything, from keybindings to window behavior, can be tweaked to your liking. This includes controlling where new frames appear. By adding a bit of Emacs Lisp code to your init file (.emacs or init.el), you can tell Emacs exactly how you want those frames to behave. This might seem daunting if you're not familiar with Lisp, but don't worry – we'll break it down step by step.

Think of your Emacs init file as the configuration blueprint for your entire Emacs experience. It's where you tell Emacs your preferences, load packages, and define custom behaviors. By adding our dual-monitor magic here, we're ensuring that every time Emacs starts, it knows how to handle new frames in a multi-monitor setup.

The Code: Making Emacs Frame Appear on the Second Screen

Okay, let's get to the heart of the matter. The magic incantation we need involves a bit of Emacs Lisp. Don't panic if you're not fluent in Lisp; I'll explain what each part does. Add the following code snippet to your Emacs init file (.emacs or init.el):

(defun my-second-screen-frame ()
  (interactive)
  (let ((screen-width (nth 2 (display-monitor-attributes (selected-monitor))))
        (screen-height (nth 3 (display-monitor-attributes (selected-monitor)))))
    (make-frame `((name . "Second Screen Frame")
                 (left . ,screen-width)
                 (top . 0)
                 (width . ,screen-width)
                 (height . ,screen-height)
                 (fullscreen . maximized)))))

(global-set-key (kbd "C-c 2") 'my-second-screen-frame)

Let's break this down, piece by piece:

(defun my-second-screen-frame () ...): This defines a new function named my-second-screen-frame. Functions are the building blocks of Lisp code, allowing you to group together actions and reuse them.
(interactive): This special form tells Emacs that this function can be called interactively, meaning you can run it by typing M-x my-second-screen-frame or, as we'll see, by pressing a key combination.
(let ((screen-width ...) (screen-height ...)) ...): This introduces a let block, which allows us to create local variables. We're creating two variables here: screen-width and screen-height. These will store the width and height of the second screen.
(nth 2 (display-monitor-attributes (selected-monitor))): This is the key to getting the screen dimensions. (selected-monitor) returns the number of the second monitor (assuming your primary monitor is 0). (display-monitor-attributes ...) then returns a list of attributes for that monitor, and (nth 2 ...) and (nth 3 ...) extract the width and height from that list, respectively. Emacs is super detail-oriented about your monitor setup.
(make-frame ...): This is the core function that creates a new frame. It takes a list of frame parameters, which control things like the frame's position, size, and title.
`` ((name . "Second Screen Frame") ...): This is a backquoted list, which is a convenient way to construct lists in Lisp. The backquote allows us to insert the values of variables (like screen-width and screen-height) using commas.
(left . ,screen-width): This sets the left edge of the new frame to the right edge of the primary screen, effectively placing it on the second screen. This is the linchpin to get Emacs to show the Frame on your second monitor.
(top . 0): This places the top edge of the frame at the top of the screen.
(width . ,screen-width) and (height . ,screen-height): These set the frame's width and height to the dimensions of the second screen, ensuring it fills the entire monitor.
(fullscreen . maximized): This tells Emacs to maximize the frame, making it take up the full screen space. This is exactly what we want, a maximized frame for Emacs in your second screen.
(global-set-key (kbd "C-c 2") 'my-second-screen-frame): This sets a global keybinding. (kbd "C-c 2") specifies the key combination C-c 2 (Ctrl+c followed by 2), and 'my-second-screen-frame tells Emacs to run our function when that key combination is pressed. This gives you a quick and easy way to summon your second-screen frame.

Loading the Code and Testing It Out

Once you've added this code to your init file, you need to tell Emacs to load it. There are a couple of ways to do this:

Restart Emacs: The simplest way is to just close and reopen Emacs. It will automatically load your init file on startup.
Evaluate the Code: If you don't want to restart, you can evaluate the code directly in Emacs. Open your init file, place the cursor after the last parenthesis of the code we added, and type M-x eval-defun. This will evaluate the function definition.

Now for the moment of truth! Press C-c 2 (or whichever keybinding you chose). If everything is set up correctly, a new Emacs frame should appear on your second screen, maximized and ready to go. If not, double-check your code for typos and make sure you've loaded the changes.

Troubleshooting Common Issues

Sometimes, things don't go quite as planned. Here are a few common issues you might encounter and how to fix them:

Frame appears on the primary screen: This usually means that the screen-width calculation is not working correctly. Make sure you have the (selected-monitor) part right and that your monitors are properly configured in Windows display settings. Sometimes, Emacs can get confused if the monitor numbering isn't what you expect.
Frame is not maximized: Double-check the (fullscreen . maximized) part of the make-frame parameters. It's easy to mistype this.
Keybinding doesn't work: Ensure that you've evaluated the (global-set-key ...) line after adding it to your init file. If the keybinding still doesn't work, it might be conflicting with another keybinding. You can try a different key combination.
Emacs complains about undefined functions: This likely means you have a typo in the code or that you haven't loaded the code correctly. Double-check the function names and parentheses.

Customizing Further: Beyond the Basics

The code we've provided gives you a solid foundation for opening frames on your second screen. But Emacs is all about customization, so let's explore some ways to take this further:

Different Keybindings: Feel free to change the keybinding to something that suits your workflow. Emacs has a vast keybinding system, so you can find a combination that's comfortable for you.
Frame Titles: You can customize the title of the new frame by changing the (name . "Second Screen Frame") parameter. This can be useful for distinguishing between frames if you have multiple Emacs instances open.
Startup Behavior: If you want Emacs to always open a frame on the second screen when it starts, you can add the (my-second-screen-frame) call to your after-init-hook. This hook runs after Emacs has finished initializing.
Conditional Frame Creation: You might want to only open a second-screen frame if a second monitor is actually connected. You can add a check for this using Emacs's display functions.

Conclusion: Emacs Multi-Monitor Mastery

So there you have it! You've learned how to make Emacs open new frames on your second screen in Windows, maximizing your productivity and screen real estate. This is just a small taste of the power and flexibility that Emacs offers. By diving into Emacs Lisp and customizing your environment, you can truly tailor Emacs to your unique needs.

Now go forth and conquer your coding, writing, or whatever else you use Emacs for, across all your screens! And don't hesitate to explore the vast world of Emacs customization – you might be surprised at what you can achieve.