The one relationship he never let go of. The post The musician Billie Joe Armstrong called the musical love of his life: “My soulmate” first appeared on Far Out Magazine.

In anticipation of episode #4, here isa is supercut of lessons 1-3 of the Atari 7800 Basic Tutorial. 1 – Hello world  This is the first in a series of videos showing my own techniques using Atari 7800 Basic.  I do not claim these are the best or only way to do things, but they are the methods I have developed over the past few years.   The code in these tutorials is designed to be simple to read, so most of it will be unoptimized.  Feel free to download  the code from Github and optimize it yourself if that bothers you.   You will find the GitHub link in the end notes. Step 1: Visual Studio code The Atari 7800. For me, it’s Atari’s most underutilized console, and the one that holds the most promise as to what can be done with a 6502 based Atari machine.  The 7800 is backwards compatible with the 2600, but sports the Maria chip designed, at the time, to move graphics around the screen like no other machine, but especially better than the Colecovision, Atari’s main competition in 1983 when design started. We will talk more about the history of Atari and the 7800 as this series continues, but for now, let’s get started by jumping in and created Atari 7800 Hello World” — The first step is to download Visual Studio Code: You can find it for the PC or Mac or Linux at code.visualstudio.com:Visual Studio Code: Visual Studio Code – Code Editing. Redefined  Once  you have downloaded that you click the plug-in extensions button on the left side of the IDE, and you will see a searchable list of all the extensions available.   There are many. Search for “Atari Dev Studio” Atrari Dev studio combines Atari 7800 Basic (created by Fred Quimby with help from Bruce Tomlin) and now maintained by Mike “RevEng” Saarna. With the plug-in you can easily compile bAtari basic code, Atari 7800 Basic code, and DASM code.  It also features a spirit editor and the A7800 emulator for easy testing. Look over on the preview pane and see the information for Atari Dev Studio Notice it was created by ChunkyPixel We are all indebted to ChunkyPixel for creating such a fine price of software. Now click the install button. Next create a new file and save it on your hard drive.   I will call mine demo1.78b The .78b extension will make sure Visual Studio Code associates the file with the 7800 compiler and provides code hints included in the Atari Dev Studio plug-in. Now we are ready to go! Step 2: Boilerplate First we will drop in some boiler-plate code of which we will need in all of Atari 7800 Basic games. I’m not going to explain every detail of every option we are using, but just enough so you can dive-in later and explore all the incredible options available in Atari 7800 Basic.      You can find detailed descriptions of all Atari 7800 Basic functions in The Atari 7800 Basic Guide (https://www.randomterrain.com/7800basic.html)  set zoneheight 16  displaymode 160A  set plotvalueonscreen on  set romsize 32k Note: All code (except for jump labels and couple other things we’ll discuss later) must be tabbed-in at least one space) The first line  “set zoneheight = 16” is how we set the horizontal band zones for sprites.  Each horizontal band can have a set number of sprites, usually 16-20 depending on how many CPU cycles it takes to draw the entire screen.   You can set this to either 8 or 16.  8 allows for more bands, but with fewer sprites in each band, while 16 has less band, but more sprites in each band.   You will need to experiment with these options, and many others to optimize your Atari 7800 game.    The next line sets the graphics mode:  displaymode 160A 160A is the most basic mode.  It is 160 x 192 pixels, which means the pixels are like tall rectangles.  Each sprite in this mode can be 3 colors plus transparent. There are other modes too: 160B allows for 12 color sprites, while multiple 320 modes allow for various hi-res screens that rely on color artifacting for multi-colored sprite display. If you watched our previous video on 7800 Sprites, you can see some of these modes in action. There will be a link in the notes. (https://www.youtube.com/watch?v=oUuy5c5_8kA&t=1s) My favorite in 160A mixed with some 160B sprites, as we will see later in these lessons. The next line,   set plotvaluesonscreen on  is used for debugging and we will talk about it later. set romsize 32k, this is the size of the cartridge.  32K is small, but we don’t need anything else yet.  There are many cartridge sizes including ones that contain extra RAM to hold data and expand the number of sprites that can be displayed. The Atari 7800 Basic guide created by Mike “RevEng” Saarna and adopted by Duane Alan Hahn, a.k.a. Random Terrain will give you detailed information about the valid options for this command, as well as invaluable information about Atari 7800 Basic.   I usually keep it open in a window while I’m working. This guide is updated often. There are many more commands and options listed in 2023 than there were in 2019 when I first started with it.   In fact, just now I discovered something new. For instance, while writing this I discovered these palette fading com,mands i’ve never seen before.  These would have saved me a lot of work on my last project. There is absolutely no way I can cover all of Atari 7800 Basic  in these tutorials My job as I see it,  is to show you these demos and  get you started.  Once you are comfortable you can devour the Atari 7800 Basic Guide, and then even tackle Assembly language some day (if that’s your thing). Anyway, for this game we will keep it simple for now and just use 32K. With 32K we will not need to bank-switch, as the 7800 can address all 32K ROM space at once. Don’t know about bank-switching?It’s a way to almost infinitely  expand the ROM addressable on cartridge. I hope these lessons are successful enough that I’m inspired to tackle it later down the road. The last line BACKGRND = $60 sets the background color.    BACKGRND=$60 Press the little “rocket” button on the bottom menu to compile and run the code we just wrote. You must have your cursor in the code window for it work work properly. The output window will show the compilation steps. When it is done, the A7800 emulator will automatically launch.  When we compile and run this program, it will go off into space with this mustard colored background.  This is a warning that something has gone wrong. What has gone wrong is that we have not displayed anything yet. Hit the Escape key [ESC] to close the A7800 emulator. If you don’t close it, your next compile might not automatically launch the emulator.  To fix this we will add a simple game loop with the _gameLoop label with a goto plus a clearscreen and drawscreen lines, and recompile. _gameLoop  clearscreen  drawscreen  goto _gameLoop clearscreen removes everything from the current  display, then drawscreen draws the sprites in the displaylist. Right now we have no sprites, just a background color. And yes, that is a GOTO. Get used to it. To recreate complex logic in Atari 7800 Basic, you almost can’t avoid using GOTO. Sorry. You can create functions, but they also take-up precious resources, so I mostly avoid themOtherwise you have goto, gosub, for:next and if:then for ALL your branching and logic. Will these limits might break your long-held religious beliefs about programming?  Probably.Will you also get used-to-it and find yourself thinking about how to solve complex problems with just a few control structures:  Also: probably.  _gameLoop is a label, which means it can be jumped to or be the start of a subroutine called by a gosub.  Our “gameloop” is simply a never-ending loop that is called 60 times a second to refresh the screen. This is done with the  last line, goto _gameLoop. All labels start in the first column, most other code must be tabbed in at least 1 space.  When we run it, this a happens Our background color is displayed — Step 3: Game Loop Next we will play with this background color settings to create a good old Atari color cycle. The Atari 7800 has a 256 color palette and we will use ½  of them. You can see the full color palette used in Atari 7800 Basic by opening the Sprite Editor or on The Atari 7800 Basic Guide. We are going to write a quick program to cycle through 1/2 of the colors. First we create a couple variables. dim bgColor  = var1  dim wait = var2 Atari 7800 Basic has a set of 126 built-in spaces for variables. They are named a-z and var1 – var99 You can also set variables to memory locations in RAM, but we don’t need to do that yet. We will create a bgColor variable  to hold the color of the background as var1 We will create wait, which we will use to wait 10 frames before we change the color. Since the NTSC Atari 7800 runs at 60hz, or 60 frames a second, that means we will change the color 6 times a second. Then we will initialize those variables.  bgColor = 0  wait = 0 Next, inside the game loop  we will increment the wait variable, and when it makes it to 10, we will set it back to 0, and increment bgColor. Then we test bgColor and reset it when it gets to 127. Why? no reason we could never reset  it and just let the byte that represents bgColor increment past 255 and it would have become 0, but most of the time we will be setting limits so this is good practice. _gameLoop  clearscreen  wait = wait + 1  if wait > 10 then wait = 0 : bgColor = bgColor + 1  if bgColor > 127 then bgColor = 0  BACKGRND = bgColor  drawscreen  goto _gameLoop Notice in the code above I used a “:” on the if statement line.  The “:” lets you have multiple lines of of code statements on the same line. Now if we compile and run the program you will see the background color changes 6 times a second. — Step 4: Hello World One final touch for this first demo. It can’t be “hello world” unless it says “Hello World”. However, the Atari 7800 does not have any kind of native text capabilities. So instead, we must load in a graphic that represents our text. Atari 7800 Basic provides functionality to turn that graphic into a character set that can be plotted like text on the screen There is a font graphic provided in the sample programs that come with Atari 7800 Basic. To get it, you need to download the Atari 7800 Basic package (see a link the notes: https://github.com/7800-devtools/7800basic/releases), or download the code for this lesson from GitHub (also in the notes) Each character in 160A mode is 4 pixels wide, and 8 pixels high (with one blank horizontal line at the bottom on most characters) You load-in in the sprite  with the incgraphic command. incgraphic font.png 160A Atari 7800 Basic 160A mode supports 4-color PNG files.  Next you use the charcterset command to set the name of the font graphic minus the extension, Then use the alphachars command to tell Atari 7800 Basic which ascii characters are represented in the font graphic  characterset font  alphachars ‘0123456789abcdefghijklmnopqrstuvwxyz>`?!/.,-_()[]&AB ‘ These “font” characters we will be displaying are just sprites cut from the font graphic, and nothing else.  That means we need to introduce the color palettes before we move on. The Atari 7800 contains 8 programmable color palettes, each containing four colors (3 plus alpha channel).  In 160A mode, a single palette is assigned when putting a sprite into the displaylist. In 160B mode, 12-color sprites use either the first 4 or 2nd 4 palettes.  We will get to that in a later lesson. By the way, these palette are completely redefinable at execution time, which makes them very useful for color-based animations. You define a palette like this:   P0C1=$0F   P0C2=$0C   P0C3=$0A This is the “0” palette, signified by the “0” after the P in the variable name. $0F is white, the other two colors are shades of grey. Now, inside our _gameLoop we can use the plotchars command to put  text on the screen plotchars ‘hello world’ 0 58 5 There are four parameters for plotchars Text to display in single quotes The color palette to use The x position of the text in pixels (0-159) The y position in lines of text (about coarse 13 lines) Optional  -number of characters Optional -doublewide Besides text, the plotchars and the associated plotmap and other commands can be used to plot map graphics for games.  These are called character graphics and while they are easy to manipulate, they have restrictions too.  Check out the Atari 7800 Basic guide for more details, Finding the right X and Y position for text may take a few iterations.  I think it took me 3 or 4 tries before it looked like “Hello World” was in the center of the screen. When we run this you should see a color cycling background with the words “Hello World” displayed in White over it. Hello World Atari 7800! You Can get the code for this and all future lessons on our GitHub:  intotheverticalblank/makeathing: Code for making things (github.com) All Links:Links:  Source GitHub : intotheverticalblank/makeathing: Code for making things (github.com) 7800 Graphics Modes And Sprites Tested: Visual Studio Code: Visual Studio Code – Code Editing. Redefined Atari 7800 Basic Github: Releases · 7800-devtools/7800basic (github.com) AtariAge 7800 Basic Forum: 7800basic beta, the release thread – Atari 7800 Programming – AtariAge Forums Atari 7800 Basic Guide: 7800basic Guide (randomterrain.com) Concerto Cart: Pre-production Concerto Cartridge | Erstwhile Technologies (square.site) Atari 7800 Basic Lesson 2: Sprites Note: This tutorial series is designed as video series. The text below is provided as a way to make it easier to follow, but I recommend you watch the video and use the text as supplemental. Introduction In Our first lesson on Atari 7800 Basic we made a simple “Hello World” program with a color rotating background. In this lesson we will begin to turn that idea into a game. The game we are making is called U.A.P. which is the modern name for U.F.O. and stands for Unidentified Aerial Phenomenon The game is based on a certain Discovery Channel TV show. In the game you play the UAP.  But that’s all we know so far. So in this lesson we will design a player sprite and get it moving on the screen with the joystick. — If you are like me, you found out about the Atari 7800 sometime in the summer 1984 reading a magazine like Electronic Games.   And the most exciting thing about the Atari 7800 was its sprite capabilities. Back then, the capabilities of most video game systems were defined by how many objects could be moved around the screen.  The Atari 2600 with the TIA chip had 5 sprites )player1, plater2, missile1, missile2, and the ball).  The Atari 5200 and 400/800 with CTIA/GTIA at 5 hardware sorites, but also a complicated displaylist and charcterset redefinition system  that made it seem like many more.   But the 7800, with it’s MARIA chip offered something different.  According to Electronic Games, it would put nearly 100 sprites on the screen, and would make a game like Robotron, then and still now, one of the most impressive arcade gamesa ever made, possible to create on the 7800 with very few compromises. But then the 7800  wide-release was canceled in 1984, and by the time it came out almost 3 years later, the NES had conquered America. When I finally did get to play the 7800 version of Robotron, I was not disappointed as it was spectacular!   There were so many independently moving objects on the screen, with no flicker, it felt like the culmination of everything we wished for in 1984.  But it was too little, too late by 1987 when I first played it.  I could only imagine what games the 7800 could have had by that year if game developers were three years into the development cycle. So To me, this is the actual lure of the 7800.The “What Could Have been”? And much of that stems from the sprite capabilities of the MARIA graphics chip. — One other note.  Atari 7800 Basic is very powerful, but it;s still a “game engine” built in assembly language that abstracts the full power of The Atari 7800.  In this regard, it’s better than bAtari Basic for the 2600, which but it’s still limited compared to programming in full Assembly language. A good indication of this is how it handles Zones. Recall, “zones” are horizontal bands, 8 or 16 pixels high.  Only a  certain number of sprites, determined by how long it takes to draw each line on the CRT, can be displayed at a time in a zone. Atari 7800 Basic abstracts the programmer from having to deal with the zones. 7800basic Guide (randomterrain.com) This is probably a good thing when you are getting started, but as you advance, you may find that you need more flexibility.  And that flexibility will come with Assembly language.  But that is too much for these tutorials so we will concentrate on what 7800 Basic can do for us. Note: The Three C’s In the last lesson I may have failed to make a few things abundantly clear. These are rules to live by when programming games in Atari 7800 Basic. I call them the “Three C’s”   Code.Case.Configuration. Well okay, I just made that up on the spot, but you’ll see what I mean Code Remember that tabs matter in Atari 7800 Basic. All regular code MUST be tabbed-in at least 1 space, or it will cause errors. All _labels for gotos and gosubs must be in the first first column. There are few exceptions, but we will talk about those if we bet to them. Case Case matters. If the code example says “32k” and the “k” is lower-case, and you use an upper-case “K”, the compiler will throw an error.  Just this one concept can save you a lot of headaches. Configuration VS Code needs to be configured to compile your code using the Atari 7800 compiler that came with Atari Dev Studio.  This usually occurs automatically if you have you saved  source files with the .78b extension.   However, if that does not occur, you need to configure VS Code to compile as a 7800 binary. Check the lower right of VS Code. If it says “7800 Basic” (white text on blue), you are good to go.  If not, click on the text in that location (it might say something like “bAtari Basic” and select Atari 7800 Basic on the selection screen. By remembering the “Three C’s” (Code, Case, Configuration) you should avoid a lot of headaches when compiling. Now onto the lesson Step – 1:  Title Screen / Game Loop First we need to separate our title screen from our game loop so we can have a place to initialize the game and a place to execute the game. We will be working from the code design in lesson 1, Hello World.   The first thing we will do is add a couple more variables : lives and score. We are not actually sure what we use these for yet, but they are indicative of the types of variables our game will use. First we will define them, then we will initialize them. dim lives = var3 dim score = var4 lives = 0 score = 0 Next we will change the name of _gameLoop to _titleLoop and make sure out goto now targets the correct label _titleLoop goto _titleLoop Let’s talk a bit about labels because I believe we glossed over the topic in lesson  1. The labels are “jump” labels and can be used with either goto or gosub.  My convention is to start them with an “_” underscore so I can easily tell them when i see them.  Label must be in the first column of a line.  Most other code must be al least 1 space in, or the compiler will barf and tell you it has no idea what to do.   Next we will change the name on the title screen from “Hello World” to “u.a.p”.  Notice we only use lowercase letters.  That is because only lower case letters were defined in our font graphic. If you want lower and uppercase letters you can draw your own font graphic.  Infact, in the 320 modes with doublewide fonts, you could get pretty elaborate with the design of a font.  If you create text-heavy game for the 7800, you may want to explore those modes and options. Next we plot the new text. plotchars 'u.a.p.' 0 68 5 Then we will test the first and second joystick buttons of the first joystick (joy0fire0, joy0fire1) and if either is pressed, we will jump to a new label named _initGame. if joy0fire0 || joy0fire1 then goto _initGame In _initGame we will reset everything.  This is redundant now, but as the game gets more complex there will be certain variables we want to initialize before the game executes and ones we want to reset every time the game starts. _initGame lives = 3 score = 0 BACKGRND=$00 And now we will create a new function named _gameLoop.  It will look pretty much like the old _titleLoop, except we draw some placeholder text that says “game” to remind us that we are no longer on the title screen, and the game is about to start. _gameLoop clearscreen plotchars 'game' 0 68 5 drawscreen goto _gameLoop When we compile and run the code, it looks like this: The title screen will still rotate colors but it says “U.A.P.” now.By pressing fire button 0 (Z-key or joystick button 0), the title screen will disappear and we see the “game” placeholder text. Now, I edited this lesson to make it look like I got all of this right the first time, but that is not the case at all. In fact, the first time I compiled I got an error, so I’ll show you what that looks like. The complier will stop and give you information to help you figure out what is wrong. The most useful information for beginners is this list of unrecognized symbols. Ignore the ones that you did not define,and look for things you might have messed-up. For this step I forgot that the name of our loop label was  _gameLoop not _gametitle.  Another common error with labels is not left justifying them. Most other code needs to be at least 1 character or tabbed in.   But labels need to be in the first column. So if I go ahead and fix the code and re-run, the code executes as expected. Step – 2: Drawing Sprites. So I’ve just been clicking things on this menu bar at the bottom of the screen and not talking about them. This little bar at the bottom right of the screen was added by Atari Dev Studio.  The functions are :  Welcome – takes you Atari Dev Studio Plug-On Page Sprite Editor – it is what it says it is  Compile Compile and Run We will spend most of our time on Sprite Editor and Compile and Run To create a player sprite for the game we will click the Sprite Editor button. You see a screen that looks like this: Now we create a new sprite file that is 16×16 with 4 colors for mode 160A, NTSC by pressing the Project+ button on the left. The windows can be arranged to make it easiest to see everything. You can grab them and move them around, resize, etc. I usually resize so I can see an entire sprite, and also the current set of sprites in sprite file I’m making.Next we set our colors.  For the sprite I’d like to white, grey and red Recall, as I draw this UAP sprite, that 160A mode have more pixels in the y, and less in the x, so we need to accommodate that when we draw. Sprite file and .spe extensions, and can hold as many sprite definitions as is reasonable to work with. .spe files are not sprites through. Each  sprite must be exported as .png to be used in a game. When I’m done designing the first UAP sprite, I want to make it animated by inserting a few little details that can move when we add more frames. I press the copy sprite button, and edit the sprite to make it animate.   I do this two more times so my UAP sprite, the player (as you play the UAP in the game) will have four frames.   … Next, I save the player sprite .spe file in a subdirectory of my project name “images”. I call it player.spe.   Then I export each individual frame as a .png file, naming them player1 through player4. Now we are ready to load this sprite into our Atari 7800 game and display it. Step – 3: Displaying Sprites Now we will display these 4 sprite frames in succession to make it look like our UAp is animating.The first thing we need to do is to create a color palette to match the colors we used in our sprite.   We can find the colors we need to set in 7800Basic by looking back in the sprite editor and rolling over each color to find it’s hexadecimal value. In this case the values are $0D, $08, $33 which are two shades of gray plus a deep red. rem pallette 1 player P1C1 = $0D P1C2 = $08 P1C3 = $33 Next we will include the sprite images we created. The order of the inclusion is VERY important. The order of the sprites is used for animating them. You can easily animate sprites that are loaded in succession. incgraphic images/player1.png 160A 0 1 2 3  incgraphic images/player2.png 160A 0 1 2 3  incgraphic images/player3.png 160A 0 1 2 3  incgraphic images/player4.png 160A 0 1 2 3  The file names of the sprites will be used directly in the code to identify them.   They can’t contain any special characters, and need to start with a  letter. After the name, you have other optional parameters. “160A” is the graphics mode of the sprite.  If you don’t specify, 7800 Basic will default to 160A, which are 3-color sprites.   However, in the next lesson we will see how we can load 12-color sprites in the same way by specifying “160B” The other numbers are color indexes.   These can be very confusing, but we will have an example in just a bit that shows how to use them. Next we will create a couple new variables to hold the X and Y location of the sprite: dim playerX =var5 dim playerY = var6 And initialize them to 0 playerY = 0 playerX = 0 In the _initGame subroutine we will then initialize the values for the start of a game: playerX = 70  playerY = 90 This is a good time to explain variables a little more in depth. In the first tutorial we told you that the Atari 7800 Basic has 126 built-in variables var0-var99 and a-z.Some functions in Atari 7800 Basic require the a-z variables, so I avoid using them. You can also assign direct memory locations to another 1535 single byte variables, which is ample space for most simple games. 7800basic Guide (randomterrain.com) Each variable in Atari7800 Basic represents a single byte, which of course can hold numbers from 0 through 255. Luckily for us, in 160A mode, the screen size is 160×192, which means a single byte can hold the X position and a single byte can hold the Y position of any sprite. Now, let’s draw the sprite in our game loop using plotsprite _gameLoop clearscreen plotsprite player1 1 playerX playerY drawscreen goto _gameLoop The plotsprite command 5 parameters: Name of sprite to display (filename without the extension) Palette number (we defined our sprite colors in palette 1) X location Y location Animation frame (optional, but we will use this soon) When we compile and test this code, our UAP sits pretty much in the center of the screen. Okay, this is where things get a bit technical. Now, let’s look at the compiler output to understand a little bit better what we have done. With the font and 4 player sprites loaded we have used just about 1K in the ROM (2992 bytes left) in the current block.  Graphics are stored in memory ROM  blocks on the Atari 7800. For a game with zoneheight of 16, the graphics blocks are 4k in size. Graphics in different blocks will not easily animate so as you create more and more graphics to load into your game, you might need to manage the order of how things are loaded.    Also, the more graphics you have, the more chances you will need to use bank switching. Blocks are created automatically when graphics are loaded, or you can use the “newblock” command to force a new block. One more interesting thing to see here The second to last line says “$1830 to $1fff used as zone memory, allowing for 31 display objects per zone.”With a height of 192 pixels and a zoneheight of 16, that means we have 12 zones. 31 display objects per zone = 372!!.  So conceivably we could get 372 sprites on the screen!! This why people were so excited about the MARIA chip in 1984! However, even though a zone can has the memory for 31 objects!, that doesn’t mean they can be displayed in the time it takes to draw each scanline. Also, those display objects are EVERYTHING including and text or background map objects, etc. Don’t worry though, there are ways to expand this using extra RAM in the cart and double buffering will help make sure everything needs to draw gets displayed. Step – 4: Animating The Sprite To animate the sprite we need a way to remember which player frame we are displaying. I like to use very very descriptive variables, so we will call this one playerAnimFrame.  dim playerAnimFrame = var7 We will initialize it before our game starts playerAnimFrame = 0 And also after our _initGame label  playerAnimFrame = 0 Then in _gameLoop we will add the playerAnimFrame variable as the last, optional parameter to plotSprite. After that we increment playerAnimFrame, then test to see if it is more than 3. If so we set it to 0.    _gameLoop clearscreen plotsprite player1 1 playerX playerY playerAnimFrame playerAnimFrame = playerAnimFrame +1 if playerAnimFrame > 3 then playerAnimFrame = 0 drawscreen goto _gameLoop Notice a couple things here. We only ever have to use the name of the first sprite, “player1”.  Because we loaded all 4 sprites in sequence, it will treat the  subsequent sprites as a “frame” of this first sprite if we use the optional frame parameter as we did here. There is no magic here.  The “frame” parameter is simply moving to the next 160A, 4-color sprite. This could be ANYTHING.  For instance, if you have an explosion that is loaded directly after the player sprite, and you don’t reset the playerAnimFrame back to 0 when it’s above 3, your explosion frames will be displayed. Now let’s test this. When you press the “rocket” and compile this version, you will see the UAP animating very quickly in the middle of the screen.   It’s neat, but too fast. There are many ways to slow this down, but we will employ one that will be necessary for our game: double buffering. 7800basic Guide (randomterrain.com) Double buffering allows you to define how many frames it will take to draw the screen. It also regulates the frames using a timing delta calculation so animation is smoother. This is a function of Atari 7800 Basic provided to help manage sprites, zones and memory, and it;s very useful one.   In our  boilerplate at the top of the program we will use the doublebuffer directive to turn on the functionality  doublebuffer on Then in _gameLoop we will replace drawscreen with this line of code doublebuffer flip 2 “flip 2” tells Atari 7800 Basic to use two frames to draw the screen. When we compile and run this version, you will see that UAP animates slower at 30fps or 30hz and not the default 60fps or 60hz.     Let’s look at the compiler output. Now the compiler tells us that we can only get 14 objects per zone.  This is because doublebuffering is turned on.  The resources needed to smooth out the animation mean there is less memory for sprites.  This is fine, don’t worry.   We were never getting 300+ sprites on the screen anyway.    There are other levers we can pull to get more sprites in zone that we will learn about later. But we are now getting closer to a more realistic number of sprites that can be displayed.     While we will ultimately need doublebuffering for this game, it’s not a great way to control the speed of animation.  Most likely we will want to control each sprite’s animation individually. To do this we will create a  new variable name playerAnimWait. We will use the variable to count frames before we move to new animation frame  dim playerAnimWait = var8 Will will also initialize it like  the other variables:  before the game start running andafter the  _initGame label  playerAnimWait = 0 And: And _initGame playerAnimWait = 0 Now, in the game loop, instead of incremented playerAnimFame every _gameLoop, we will count to “3” by incrementing playerAnimWait.  Every time it goes above 2, we will then increment playerAnimFrame.   By doing this we will get much more control over the speed of the sprite animation. _gameLoop clearscreen plotsprite player1 1 playerX playerY playerAnimFrame playerAnimWait = playerAnimWait +1 if playerAnimWait > 2 then playerAnimFrame = playerAnimFrame + 1 : playerAnimWait = 0 if playerAnimFrame > 3 then playerAnimFrame = 0 doublebuffer flip 2 goto _gameLoop When you compile and run this time, you will see that the sprite animated slower, but also that the middle portion doesn’t look quite right.  Now that we actually can see the sprite, we can also see how it animates.  Let’s go back into the sprite editor and update the frames to make a different animation,. Instead of animating horizontally, let’s make the middle portion animated vertically.  … Now. Save the player.spe when we are done, and export each frame again. When we compile and run the code again, something odd happens.  It looks like a couple of the colors are different than what we defined in the spirite editor. This happens a lot.   There is an explanation for it, about how the different indexes get transposed depending on which color is used first, or something, but I’ve never quite understood.  What it means in practical terms is that you can’t always trust the colors as they are saved in the .png, and you might have to reorder the indexes. The good news is, there is an easy way to fix this, but it might take bit of trial and error.Remember those final parameters on the incgraphic command: incgraphic images/player1.png 160A 0 1 3 2 incgraphic images/player2.png 160A 0 1 3 2 incgraphic images/player3.png 160A 0 1 3 2 incgraphic images/player4.png 160A 0 1 3 2 These are the MARIA chip color indexes.  To fix this little color glitch, all we need to do it swap the 2nd and 3rd indexes when we load the sprites . Now, when we compile and run, the colors look correct, and the animation is smooth. By the way, Atari 7800 Basic has some recent functionality that allows the programmer to extract color values directly from the loaded .PNG sprites. And putting them into color constants: 7800basic Guide (randomterrain.com) I have not used this functionality yet myself,  but it looks very interesting. (now, now I HAVE used it, and it will feature in a future lesson). Step – 5 : Move The Sprite! Let’s finish up this lesson by allowing the player to move the UAP around the screen using  joystick 0. Honestly this is the easiest lesson yet. All we need to do is stick this very much self-explanatory code in _gameLoop:  if joy0left  then playerX=playerX - 1 if joy0right then playerX=playerX +  1 if joy0up  then playerY=playerY - 1 if joy0down then playerY=playerY +  1 We will move the UAP 1 pixel depending on which direction of joy0 is pressed.  This code is in no way optimized.  We should add a “controlWait” counter as well, or we will read the joystick or fire button 30 times a second which might be too many. But for now, let’s compile this code and start moving! Well that is it for lesson 2.  Be sure to read the notes and download the code from GitHub.Good luck and let;s get some great new games on the Atari 7800, history’s most underutilized game console! Until next time, Into The Vertical blank! Feel the urge to support, click here (but no obligation): https://www.buymeacoffee.com/intotheverticalblank?fbclid=IwAR0ryLpAIZPgDgjZqSmMmXLVIOFKWtSDVymoPXsJoj3KsEI0x0KCQOpJMpM You Can get the code for this and all future lessons on our GitHub:  intotheverticalblank/makeathing: Code for making things (github.com) All Links:Links:  Source GitHub : intotheverticalblank/makeathing: Code for making things (github.com) Visual Studio Code: Visual Studio Code – Code Editing. Redefined Atari 7800 Basic Github: Releases · 7800-devtools/7800basic (github.com) AtariAge 7800 Basic Forum: 7800basic beta, the release thread – Atari 7800 Programming – AtariAge Forums Atari 7800 Basic Guide: 7800basic Guide (randomterrain.com) Concerto Cart: Pre-production Concerto Cartridge | Erstwhile Technologies (square.site)\ Atari 7800 Basic Lesson 3: Title Screens Part 1: Title Screen Do title screens matter? I think they do. They are like the bow on the wrapping of a present: Not necessary, but kinda cool none-the-less, and almost expected once you realize it is not there. If you didn’t grow-up in the golden age of Atari video games, you might not realize that a decent title screen for a game was not always a foregone conclusion.  Many computer games had nice title screens, as did arcade games. Computer games had their pedigree from college campuses and the garages and bedrooms, of hobbyists, where free expression was not only possible but encouraged.  Early companies like Sirius, Broderbund and MUSE making games for the computers like Apple 2, TRS-80 and Atari 800 used nice title screens to introduce their games in imaginative ways. Arcade games had to stand alone in large rooms begging for quarters, so very early it was established that they could benefit from elaborate attract modes and title sequences to get people interested in the games they held inside. But early video games systems with their comparatively limited storage, memory and processing capabilities eschewed title screens for color-cycling static screens, and let the box and manual do the talking.   They needed to get as much bang from very little buck as possible. Astrocade, Channel F, Odyssey 2 But this held true even when conventional wisdom might make you think it was not so. Even Atari VCS games one might think would have elaborate title screens given their relative importance and history for the VCS, really did not. Games like Superman, Adventure, Asteroids, Space Invaders, Missile Command, Yar’s Revenge, Pac-Man, Defender, Berserk and Vanguard eschewed any type of window dressing so every single bit of ROM onto the screen. Asteroids, Missile Command, Pac-Man The first exception to this might have been Howard Scott Warshaw’s twin releases of Raiders Of The Lost Ark and E.T. both of which featured elaborate title sequences.   Both Mattel and Coleco, Atari’s main competitors at the time, used uniform start-up screens that helped give their games a sense of community with the rest of the titles. Mattel used a standard  Green with white text title screen that was facilitated by the  system ROM. Coleco used an attractive branding of their logo with simple text to introduce the game, that usually lead into a game select screen.   While not exciting, they were attractive in a way that made it look like Coleco cared about having a common look and feel.  This changed over time. By the time War Games and Rocky were released they had added some animated intros that while not exactly title screens, seemed to understand the concept. I can’t pinpoint the exact moment title screen became important for VCS games, but it was sometime after the release of Ms. Pac-Man in the spring of 1983 when Atari was struggling to make a profit and losing game player mindshare to the likes of Coleco who brought fresh perspective to home video games with arcade-like graphics matched with unique games that did not feel stale.  For instance, Coleco’ pack-in game was Donkey Kong, then still one of the hottest games in the arcade.  By contrast, Atari’s 5200 included Super Breakout that, while a decent game, was almost 6 years old at the time. While the 5200 used a common intro screen similar to Coelco and Intellivision Many of the actual title screens were taken directly from their Atari 400/800 brethren, and while functional, many were not very impressive or uniform and made the games for the system seem like they were created willy-nilly.  In fact, after reviewing them for this lesson, I was surprised at how slap-shod they look.  Individually they are fine, but as the “Super System” from Atari, they look amateurish.  So by late summer 1983, The 5200 was not selling well, the VCS business was crumbling because of poor distribution planning and loss of consumer confidence in the platform, while the Colecovision was killing it.    Atari needed to do something.   The approach to title screens on VCS games became much more elaborate.  Maybe this was a directive from inside Atari, or maybe it was a result of many of the games being contracted out to GCC, the inventors of Ms. Pac-Man and the eventual designers of the Atari 7800.Whatever the reason, VCS arcade translations games like Centipede, Dig Dug, Phoenix, Jungle Hunt, and Moon Patrol each contained elaborate title screens and attract modes that went far beyond the arcade games from 1980-1982.   Atari 2600 Arcade Conversions These games were 8 and 16K carts that used bank-switching to creating their impressive title screens.  Even if the games themselves could not match Coleco’s near arcade quality, they title screens might pull some people in.  In may ways, these title screens from latter VCS games are like animations from the later Amiga and ST “demo scene”.  They push the limits of the system in ways no one ever thought possible.  In some cases it was lipstick on a pig, but you can’t deny that some of the title screens (and also many of the games) from the last years of Atari Inc.’s VCS output were pretty impressive. For the 2600 and the 5200, the epitome of the title screen might be Gremlins, a game released for the Atari 800, 5200 and 2600 near the end of Atari’s inc’s reign in the summer of 1984.    Both feature attractive title sequences and colorful, decent action games. 5200 Gremlins It feels like Atari finally learned their lesson on how to present their games that were translations of from other popular media, but it was too little, too late.    With the 7800, it appears Atari was not going to make the same mistake. When it came to the first batch of games GCC designed for the 7800, it is apparent that good title screens were not an afterthought.   Since the 7800 was a very capable machine, it was the first time all the games had some kind of standardized title screen. In fact the first 11 games, all developed for release in 1984, used a very similar style of title screen. First batch of 7800 games from 1984 While not all of the screens and logos matched the arcade counterparts, the effect of was a pleasing, almost uniform style for the first time on an American video game console.When the 7800 was finally released, the 2nd wave of games like Dark Chambers and Cracked used a wide variety of different title screen styles, as did. Later 7800 games used even more elaborate title screens that mirrored 3rd party screens for competing platforms, for example, Alien Brigade and Motropsycho. As a kid, I followed each nuanced change, update and advance to video games like it was a work of great art.   I loved Atari, but I could see how they were faltering.  Seeing the title screens 7800 AND gameplay  gave me hope that Atari was doing it right.  However, since these games would not see the light of day for almost two more years, the NES beat the 7800 to the punch with it its own uniform style.   And this, like many other things we’ve discussed in out video and podcast over the years, is essentially what we call “The Vertical Blank”.  It’s “what could have been” .   The nice thing is, with Atari 7800 Basic we no longer have to speculate about “what could have been”, we can just try it ourselves.  It may not be a time machine that lets us go back and change the course of video game history, but it just might be the next best thing, I try to create a title screen for my games as soon as possible, because it makes me believe they are “real”. However, from my own personal track record of releasing 7800 games (one), you might think the title screen would be paramount.  In fact, my single “released” games, my Last Stand Halloween demo, is the one game I never made a title screen for.  Oh well. Note:  Atari 8-bit In the last episode I said the Atari 400/800 could display 5 sprites.  While this is technically true, it needs more explanation.  The Atari 400/800 could display 4 sprites and 4 missiles and the four missiles could be combined into a 5th sprite.   The point though, was that the 7800 Maria chip was completely different kind of architecture.   Part 2: What Game Is This? So now it;s time to take a step back and think about what kind of game we want to make.  Don’t worry, we will get some coding  done in this lesson too, but just for a bit, let’s think on what exactly we are doing here. To get inspired, first I’m going to create a “banner” graphic (one that is larger in height that the zoneheight), In this case 96×32.And we are going to do it in 12 color. This is graphic designed for Atari 7800 graphic mode 160B Here goes! (watch the video to see the title being drawn) There is a show on The History Channel named The Secret Of Skinwalker Ranch.   If you have not seen it, it’s about a real ranch that is supposedly some kind of portal or interdimensional gateway.  On the show they are always shooting rockets into the air with various sensors, trying to simultaneously get UAPs to appear and to figure out where they might be coming from.   They use cows as “biosensors” because there have been some supposed animal mutilations in the area, they fly drones, and the owner of the ranch uses a sleek, black helicopter, flown by his brother, to help with the experiments.  It’s simultaneously fascinating and preposterous.   But for the sake of this game we will pretend like it’s all true and there are many ranches like Skinwalker with interdimensional portals above them, and this game takes place on one of them, but not necessarily the one from the show. The UAP you are flying is sort of interdimensional Uber transport. When a level starts, you arrive above the ranch in your UAP.  The portal you came through closes, and the next portal will not open until you collect enough “orbs” to energize the next one.   With enough “orbs” collected, the next portal opens and you can slip through to whatever dimension you need to go. But while you are on the screen collecting orbs over the ranch,  the “scientists” on the ground will be shooting rockets at you.   They will send drones, and if you miss too many “orbs” the black helicopter will show-up. If you collide with any of the objects, your “visibility” factor will go up. The worst thing for a UAP is to be so visible that someone can take a full photo of you. If you hit 3 objects on any level, a photo is taken, and the game is over. However, you have a chance. Cows happen to be your saving grace.  If a cow appears on the ground, collect it and your visibility will go down. You also have your own 1.6ghz wave-beam that can shoot the enemies out of the sky, but you can only have one beam on the screen at a time, so use it wisely. And that’s it.  Each level will get harder and harder, but that’s the basic game. We will use the full screen for the game,and let the player UAP move anywhere.  They game will be styled a bit like Robotron, and we will use it as a way to see just how many animated spirited we can get on the screenNow let’s load-in that title screen image we just made, and get moving! —- Part 3: More Memory And The Banner So let’s start by changing a bit of the boilerplate we used in the previous lessons.   Remember when I said we may only ever need 32K?  Well, that was just to not confuse things.  But now that you have some idea how things work, and you have seen a little a bit of how the 7800 uses memory, let’s expand the cartridge format a bit. set romsize 128kRAMset dlmemory $4000 $7FFF The first line sets the cartridge to 128K ROM, which will give us eight 16k banks to work with.  We will not talk about bank-switching yet, we are just getting ready for it.   The RAM of “128kRAM” means the cartridge we will be using has an extra 16K RAM available and addressable at all times.   THIS IS HUGE.  The Atari 7800 by default has 4K of RAM, which is okay, but not great if we need to track and display lots of objects on the screen with lots of properties.   “Set dlmemory $4000 $7FFF” takes extra RAM and uses it to expand the DisplayList of the 7800, which in-turn will allow more objects per zone.     So now Let’s display our title screen. To do this we will use a new function named “incbanner”.  incbanner tell Atari 7800 Basic that the graphic we are loading extends higher than the current zoneheight of 16. incbanner  images/title.png 160B Notice the 160B that comes after the filename.  That tells Atari 7800 Basic that we want to load a 12-color bitmap. In our _titleLoop function we will now display the title graphic using the plot banner command.  plotbanner title 0 32 50 Plotbanner is similar to plotsprite.  The first parameter is the name of the graphic to display, followed by the palette, and x and y location.  Notice only set a single palette, even though the sprite use the 12  colors.   This is because 160B sprites uses the first four or 2nd four pallettes.   For a 12-color graphic specify palette 0 for the first 12 colors, or palette 4 for the 2nd 12 colors Save the file, then let’s test it out.First but let’s look at the output window. Notice at the top, it loaded “title” as two sprites, title00 and title01. That’s what loadbanner does. Also, before we loaded the title, we has 2992 bytes left in bank#1, now we only have 1456, so the title with 12 visible colors is about 1.5K in size!   160B sprites can be large, so it’s good idea to limit them or manage them into multiple ROM banks.It now says we can have 136 objects per zone.  This is because of extra memory we added.  Now, practically, there will be no way to get 136 objects per zone in an action game, and we may find out we need some of that extra RAM for our active game data, but for now we will just keep it like this. What you will see is something like this: The colors are all wrong and we still have that color cycling background. The first thing we will fix is the colors. Recall, we set the color palette for text and sprites above all of our code in our previous examples.  But we need to be more flexible than that.  The color palettes on the 7800 are redefinable at run-time, and we want to make use of that feature. So first, let’s move our original color palettes to _initGame. _initGame lives = 3 score0 = 0 BACKGRND=$00 playerX = 70 playerY = 90 playerAnimFrame = 0 playerAnimWait = 0 rand = randomSeed gosub _randomOrb orbAnimFrame = 0 orbAnimWait = 0 rem pallette 0 text P0C1=$0F P0C2=$0C P0C3=$0A rem pallette 1 player P1C1 = $0D P1C2 = $08 P1C3 = $33 rem orb colors P2C1 = $92 P2C2 = $94 P2C3 = $99 Next, we will create a new label named _setTitleColors. This label will allow ud to set the colors once and then drop into _titleLoop. We donlt need this function now, but when we have a function to restart the game, we will want reset the colors so the title graphics displays correctly Then, after the _setTitleColors label, we will load all the color constants that Atari 7800 Basic created for the titlegraphic. _setTitleColors P0C1 = title_color1 P0C2 = title_color2 P0C3 = title_color3 P1C1 = title_color4 P1C2 = title_color5 P1C3 = title_color6 P2C1 = title_color7 P2C2 = title_color8 P2C3 = title_color9 P3C1 = title_color10 P3C2 = title_color11 P3C3 = title_color12 Recall that this is a new feature I just discovered by reading the Atari 7800 Basic Guide (I think from lesson #1).  Previously in my games, I had to set all of these colors manually.  In some cases, it took DAYS to swap all the colors of a multi-sprite, 12-color graphic, just to get them right. However, these new constants are created when the graphic is loaded, in the format of [filename]_color[x}.  So now we can set the first 4 palettes on the 7800 with these constants!  It makes everything easy.    How 160B, 12 color images use the 7800 color palettes Now that we have set the colors, let’s run the program again and see what happens. Ah look our colors are right. Part 4: Cleaning Up So now that we have a proper title screen graphic, and we have idea for what we are making, let’s clean this up.   We no longer need to cycle the background color, as. Let’s be honest, it’s pretty annoying. We will also add a subtitle “Quantum Lay Over”, because in the game we are at sort of interdimensional rest-stop, waiting to get out. We will also add the and then the text “Fire To Start” as an instruction to the player . _titleLoop clearscreen plotbanner title 0 32 50 plotchars 'quantum lay over' 3 47 6 plotchars 'fire to start' 2 54 10 if joy0fire0 || joy0fire1 then goto _initGame randomSeed = randomSeed + 1 if randomSeed > 254 then randomSeed = 1 drawscreen goto _titleLoop For the new text we set the palette colors to 3 and 2, which will use the colors in those palettes to display the text.   I’ve rearranged the locations a bit to optimize the look of the title graphic and the text. When we run it, we see this, which I think is not too shabby. And there we have it, a decent little title screen for our 7800 game.So that was shorter lesson this time, but we learned some value things about sprites, colors and memory.  Get the code from GitHub here:makeathing/Atari7800/Atari7800Basic/Tutorial at main · intotheverticalblank/makeathing · GitHub

by Michael Snyder, End Of The American Dream: When I learned that nearly 12,000 German companies had gone bankrupt during the first half of 2025, I knew that I had to write about it. The German economy has been deeply struggling for more than two years, and now it appears that a breaking point is […]

from ZeeeMedia: TRUTH LIVES on at https://sgtreport.tv/

John Rich Speaks Out After Diddy Verdict #diddytrial #countrymusic #country

Trump vs. Elon: EV mandate's edition

A new plan is quickly emerging that could strip Democrats of a significant number of House seats AND Electoral College votes! And as with everything in the Trump 2.0 Administration, things are moving very fast. It all started with Marjorie Taylor Greene floating out the idea to eliminate the “Census Fraud” put into place by the Biden Regime and order a brand new census to be put into place immediately that would only count actual U.S. Citizens! Not residents… Not illegals… Not green card holders… But only U.S. Citizens, which is the only truly legal way to do it. You can see her lay out the plan here: The American people are underrepresented thanks to Biden’s census fraud. My bill: Orders a new census of U.S. citizens only. Directs states to redraw House maps accordingly. Ends non-citizen voting in federal elections. President Trump backs it. Now let’s pass it. pic.twitter.com/8Od3PpgAcA — Rep. Marjorie Taylor Greene (@RepMTG) July 2, 2025 News almost immediately spread to President Trump who said he was aware of the plan and supports it 100%. Watch here: JUST IN — President Trump and Gov. Ron DeSantis join the call for a NEW, more accurate Census. 2020 was a completely bastardized and flawed process. Only American citizens should be counted. Republicans will gain at least 10 seats, probably more. Let’s go!!! https://t.co/Kwhl3uOSNf pic.twitter.com/cmOfp87Z2E — Charlie Kirk (@charliekirk11) July 1, 2025 Elon actually exposed this in 2024 in that trainwreck interview that ended Don Lemon’s new podcasting career: JUST IN: President Trump supports an upcoming bill that would block illegal immigrants from counting in the U.S. Census. If passed, the move would likely take away House seats from Democrats. Back in 2024 during an interview with Don Lemon, Elon Musk explained the Democrat… pic.twitter.com/BI923rGGgo — Collin Rugg (@CollinRugg) June 30, 2025 The best news? Stephen Miller is not only aware of it, but truth be told I think he’s probably the brainchild of it in the first place. And details are now emerging that Miller has already been running with it: BREAKING: The White House is currently working on ways to EXCLUDE illegal aliens from the US census, per Stephen Miller This would take away SEVERAL House seats from places like California, as seats are determined by population GET IT DONE! No illegals in the census! pic.twitter.com/3xlv9zwRbG — Nick Sortor (@nicksortor) June 30, 2025 You can almost take it to the bank that when Stephen Miller sets his sights on something and locks in, it’s going to get done! But now break down what exactly this means… I went to ChatGPT and gave it detailed instructions to analyze what would happen in terms of House Seats and Electoral College votes if this were actually put into place immediately and all non-citizens were removed from the Census. I told it to do “DeepResearch” and it actually took about 20-30 minutes as it chewed through all the data. I’m going to give you those full reports down below, but I don’t want to hide the ball or bury the lede so first let me just give you the short answers… House Seats: ChatGPT estimates that blue states are hit bad, and red states gain big, with a minimum of 3-5 house seats shifting Republican, but perhaps the more likely figure is 10-14 seats shifting Republican because that’s how many shifted Democrat when Biden recounted in 2020 and included all non-citizen illegal aliens. Electoral College: In the Electoral College, ChatGPT estimates Red States pick up 6 Electoral College votes and Blue States lose 6 votes which is MASSIVE 12 vote swing from where things were at in 2024. Now for the full analysis for anyone who wants to go DEEP on this… House Seats: Impact of Excluding Non-Citizens on 2025 Congressional Apportionment Introduction & Methodology Under current law, congressional apportionment is based on total population, counting all residents (citizens and non-citizens) in each statefactcheck.org. The U.S. Constitution’s 14th Amendment specifies apportionment using the “whole number of persons in each State,” and the Supreme Court has affirmed that “persons” includes every resident regardless of citizenship or legal statusthirdway.orgthirdway.org. In practice, this means even non-citizens (including lawful permanent residents, visa holders, and undocumented immigrants) have always been counted for dividing House seats. Scenario: Suppose that in 2025 the apportionment were recalculated using only U.S. citizens, excluding all non-citizens from state population counts. To estimate this impact, we use the latest available data on non-citizen populations by state (from the Census Bureau’s American Community Survey, ACS). The ACS 2015–2019 five-year estimates (weighted to 2020) report about 22.16 million non-citizens nationwide, ~6.8% of the U.S. resident populationthearp.org. Subtracting these non-citizens from each state’s 2020 census population gives a “citizens-only” population for apportionment. We then apply the standard Method of Equal Proportions (the same formula used in the 2020 census) to allocate 435 House seats among the 50 states based on citizen-only populations. Each state is guaranteed one seat, and the remaining seats are assigned by ranking states by priority values (a function of population) until all seats are distributedpewresearch.orgpewresearch.org. This analysis assumes no change in the total number of House seats (still 435), so any seat gained by one state means a seat lost by another (a zero-sum shift). State-by-State Seat Redistribution Using the citizen-only apportionment model, a significant shift in House seats would occur. States with large non-citizen populations would lose representation, while states with smaller non-citizen shares would gain. Table 1 below details the projected changes for each state that would lose or gain seats if only citizens were counted (states not listed would see no change in seat count). The “Current seats” reflect the actual House seats each state received after the 2020 census (based on total population), and “Adjusted seats” is the recalculated number if apportionment were based on citizens only. The net change column shows the seat loss (–) or gain (+) for each state, and the estimated partisan impact indicates which party would likely hold the lost or newly gained seat, based on the state’s political makeup and recent voting patterns in those districts. Table 1. Projected House Seat Changes with Non-Citizens Excluded (Citizen-Only Apportionment) State Current House Seats (2020 apportionment) Adjusted Seats (Citizens-Only) Net Seat Change Likely Partisan Impact (lost or gained seat) California 52 48 –4 Loss of 4 seats (likely Democratic seats lost, given California’s delegation is overwhelmingly Democratic)cis.org. New York 26 24 –2 Loss of 2 seats (likely Democratic seats lost; NY is Dem-leaning, though one loss could come from a GOP-held district). New Jersey 12 11 –1 Loss of 1 seat (likely Democratic; NJ is blue and a Democratic seat would likely be eliminated). Illinois 17 16 –1 Loss of 1 seat (potentially a Republican seat lost – Illinois’ Dem-controlled map would likely cut a GOP district). Colorado 8 9 +1 Gain of 1 seat (expected Democratic advantage; Colorado’s population growth is around Denver and trends blue). Florida 28 29 +1 Gain of 1 seat (likely Republican; Florida’s GOP legislature would likely draw a new GOP-leaning district). Louisiana 6 7 +1 Gain of 1 seat (likely Republican; Louisiana is strongly red – though a new seat could raise pressure for a second minority/Dem district). Missouri 8 9 +1 Gain of 1 seat (likely Republican; Missouri is heavily GOP, so new district would favor the GOP). Montana 2 3 +1 Gain of 1 seat (likely Republican; Montana is a deep red state – a third seat would likely elect a Republican). North Carolina 14 15 +1 Gain of 1 seat (likely Republican; GOP-controlled redistricting in NC would ensure a GOP-leaning new district). Oregon 6 7 +1 Gain of 1 seat (likely Democratic; Oregon’s Democratic legislature would likely draw the new seat favorably for Democrats). Texas 38 39 +1 Gain of 1 seat (likely Republican; Texas’ GOP legislature would design a new district favoring Republicans). Sources: These projections are based on 2019 ACS-estimated citizen populations, projected to 2020. According to the American Redistricting Project’s analysis, California would lose four seats, New York would lose two, and New Jersey and Illinois one each, while Colorado, Florida, Louisiana, Missouri, Montana, North Carolina, Oregon, and Texas would each gain one under a citizens-only countthearp.org. The current seat counts are from the official 2020 census apportionment. Partisan impact assessments are inferred from each state’s recent voting patterns and control of redistricting. For example, California’s delegation is almost 80% Democratic, so most of the four eliminated districts would likely have been Democratic-held seats. In Illinois, where Democrats control map-drawing, an eliminated district would probably be one of the few Republican-held seats, as Illinois Democrats would seek to maintain their advantage. In contrast, new seats in Republican-dominated states (Texas, Florida, etc.) would be drawn to favor GOP candidates. Major Shifts and Trends The redistribution above reflects major shifts in political representation if non-citizens were excluded. Notably: California’s dramatic loss of 4 seats underscores its large non-citizen population (over 5.3 million non-citizens in 2019 ACS data) and the heavy impact on immigrant-rich statesthearp.org. California would drop from 52 seats to 48 – a reduction of ~8% of its House delegation. Such a steep loss is unprecedented in modern times; it would diminish California’s influence in Congress and the Electoral College (costing it 4 electoral votes as well). New York’s substantial loss of 2 seats (from 26 to 24) likewise reflects its high immigrant population (especially in NYC). This would be on top of the seat New York already lost in 2020. A loss of two more would shrink NY’s delegation to 24, its lowest since the 1820s. Both California and New York – traditionally Democratic strongholds – would see their political clout erode under citizen-only apportionment. New Jersey and Illinois (also states with large immigrant communities) each lose 1 seat, continuing a trend of population-share decline in the Northeast and Midwest. Gains in mid-sized and smaller states: Several states with relatively fewer immigrants would pick up seats. Texasparadoxically gains +1 seat despite its large non-citizen population; this is because while Texas has many non-citizens, states like CA and NY have even higher shares, so Texas’ relative share of the citizen-only population actually grows enough to snag an additional seat. This would give Texas 39 seats, further closing the gap with California’s delegation. Florida gains an extra seat as well (going to 29); even though Florida has many non-citizens (e.g. in Miami), its booming citizen population still elevates it in rank once California and New York are knocked down. North Carolina, Colorado, Oregon – all states that gained 1 seat from the 2020 census – would each gain yet another seat with only citizens counted (each moving up one more notch in the apportionment list). Colorado would have 9 seats instead of 8, reflecting its growth and moderate immigrant share. Oregon would get 7 instead of 6. North Carolina would go from 14 to 15. Notably, Montana – which only just regained a 2nd seat in 2020 after decades of having one at-large district – would actually jump to 3 seats under this scenario, an unusual expansion for a rural state. This occurs because Montana has a very small non-citizen population, so its citizen population is relatively larger compared to states like New Jersey or Illinois in a citizen-only count. Similarly, Louisiana and Missouri (states that have not gained seats in many decades and in fact have lost seats over time) would each gain one seat, reversing long-running trends of stagnant or declining representation. Their low immigrant populations give them a boost in this redistribution. These shifts highlight a clear pattern: states with higher shares of non-citizens (many of them traditionally “blue” states or urbanized states) lose out, and states with lower non-citizen shares (often “red” or less urban states) benefit. In total, eight seats would be reallocated away from four states (CA, NY, NJ, IL) and given to eight other states. This reflects a sizable re-balancing of political power among the states. Partisan Impact Analysis Politically, excluding non-citizens from apportionment would likely advantage Republicans overall – though not by as much as one might intuitively expect, and not enough on its own to radically change the partisan balance of the House. The reason is that while the state shifts are significant (from blue states to red states), the question of which party wins or loses each specific seat depends on district-level politics and redistricting choices: Democratic-Leaning States Lose Seats: The states losing seats (California, New York, New Jersey, Illinois) are all Democratic-leaning at the state level. This means the pool of lost seats comes largely from areas that favor Democrats. For example, California’s four eliminated districts would likely be in areas currently represented mostly by Democrats, simply because Democrats hold roughly 80% of California’s seats. New York’s two lost seats would probably also both be Democratic-held (especially if the Democratic-controlled NY legislature were drawing the new map – they would not sacrifice their own safe seats if they can instead eliminate a Republican-held seat, but even after aggressive gerrymandering, at least one Democratic seat would likely be lost). New Jersey’s delegation is predominantly Democratic (currently 9D–3R), so a reduced map would likely pit two Democrats against each other, eliminating one Democratic seat. In total, one can estimate that out of the 8 seats lost by these four blue states, perhaps 5–6 were held by Democrats and a couple by Republicans. Illinois is a special case: Democrats there could use the loss as an opportunity to eliminate one of the few Republican districts (since Illinois’ legislature is Democrat-controlled). Thus Illinois’ lost seat might actually come at the expense of a Republican incumbent. Overall, though, the majority of the seats being eliminated are Democratic-held, reflecting the fact that immigrants bolster representation in Democratic areascis.orgcis.org. Republican-Leaning States Gain Seats: Most of the states gaining seats are Republican-leaning (Texas, Florida, North Carolina, Missouri, Louisiana, Montana). These new districts would likely favor the GOP. In states where Republicans control redistricting (e.g. TX, FL, NC, MO, LA), mapmakers would almost certainly draw the new seat to elect a Republican if at all possible. For example, Florida’s legislature (and governor) is Republican; when Florida gained a 28th seat in 2022, the resulting map was drawn to heavily favor Republicans (yielding a 20R–8D delegation). A 29th seat in Florida would presumably be drawn in a GOP-friendly region, adding another Republican to Florida’s ranks. Texas, with unified GOP control, would likely carve out a new district in a conservative area or configure it to dilute Democratic voters, aiming to elect a Republican. North Carolina’s situation is similar – a new 15th seat would be drawn in the upcoming GOP gerrymander (NC’s legislature has already signaled plans to redraw maps) likely as a Republican-leaning district. Missouri and Montana are solidly red – any new seats there would almost certainly be won by Republicans. Two of the gaining states, however, lean Democratic: Colorado and Oregon. Colorado uses an independent commission for redistricting, but given recent trends (Colorado went 5D–3R in House seats in 2022), a new 9th district might be at least competitive if not Democratic-leaning (depending on where the population growth is concentrated). Oregon’s Democratic legislature would have control over drawing a 7th district – they would likely create a district favoring Democrats (much as Oregon’s 6th seat added in 2022 was drawn to be Democratic-leaning). Thus, out of the 8 new seats created, it’s plausible that 5–6 would lean Republican and 2–3 Democratic. Combining these effects, the net impact on party seat counts would likely be a modest loss for Democrats and a modest gain for Republicans. A reasonable estimate is that Democrats would likely lose on the order of 3–5 House seats, net, under a citizens-only apportionment, shifting those seats to GOP control. For instance, one detailed analysis found that counting all immigrants (citizens or not) in 2020 tended to shift about 10–14 seats into Democratic-leaning states that they wouldn’t have if only citizens were countedcis.org. In our scenario, removing non-citizens would reverse some of that, effectively tilting a few seats back toward Republican states. Another study (focused only on undocumented immigrants) found virtually no partisan net benefit to Democrats from including that subsetfactcheck.orgfactcheck.org – meaning excluding just undocumented immigrants alone would have been roughly a wash in 2020. But when all non-citizens are excluded, the larger numbers concentrated in blue states like CA and NY mean a greater effect that likely doesbenefit Republicans slightly. In short, Democratic stronghold states lose several seats, while Republican states gain several – however, because Democrats can sometimes mitigate damage through redistricting (e.g. eliminating an opposition seat) and because a couple of gains are in blue states, the partisan change is not extreme. It would probably be enough to cost Democrats a few seats in the House, potentially making it harder for them to attain or hold a majority. For example, if these changes had been in effect for the current Congress, the slim GOP House majority (222–213 after 2022) might have been a bit larger – perhaps on the order of 225–210, making GOP control slightly more secure. It’s worth noting that the partisan impact is ultimately limited by geography: non-citizens are heavily concentrated in a handful of states (and mostly in metro areas). These areas already vote overwhelmingly Democratic, so “extra” seats there don’t always equate to additional Democratic wins in Congress beyond what they would win in a smaller delegation. Conversely, many of the gaining states are already overwhelmingly Republican, so additional seats simply add more Republican members. The result is a net tilt, but not a dramatic overhaul of House control. Political analysts have observed that including non-citizens has thus far not drastically altered the partisan balance of Congressfactcheck.org, although it does shift representation toward certain states and communities. Excluding non-citizens would reverse that representational shift, to the detriment of diverse, immigrant-heavy regions and likely to the benefit of whiter, more rural regions (which tend to favor the GOP)houstonlawreview.org. Political Implications The implications of this shift would be far-reaching. Representation in Congress drives not only the number of House members but also each state’s influence in the Electoral College (electors = House seats + 2 senators). Under a citizens-only apportionment, large immigrant-rich states like California, New York, New Jersey, and Illinois would see their electoral vote clout reduced, while states like Texas, Florida, and others would gain electoral votes. For example, California would lose four electoral votes for presidential elections, while Texas and Florida would gain one each, and so on, potentially affecting the balance of power in close presidential contests. (However, even a shift of a few electoral votes likely wouldn’t swing recent presidential outcomes by itselffactcheck.org, barring an exceptionally tight race, since recent victories have margins larger than the 3–4 vote swing this scenario might produce.) More broadly, excluding non-citizens from apportionment would ignite intense political and legal battles. The change would disproportionately affect states and districts with large immigrant communities – which are often urban, ethnically diverse, and Democratic-leaning. These communities (e.g. Los Angeles, Miami, New York City, Chicago’s immigrant neighborhoods) would face diminished representation even though they are home to millions of people, many of whom contribute to the economy and society but lack citizenship. This raises issues of fairness and equal representation: members of Congress from affected areas would argue that hundreds of thousands of residents in their communities would no longer “count” toward representation, effectively diluting the political voice of areas with more immigrants (who are often people of color). On the other hand, proponents of a citizen-only count (generally Republicans from states with fewer immigrants) argue it’s unfair for states to gain seats due to populations who are not eligible to vote. They contend that counting only citizens would align representation more closely with the voting electorate. Indeed, Republican lawmakers have periodically proposed requiring the census to count only citizens. In early 2023, the House of Representatives (then GOP-controlled) even passed a bill (H.R. 151, the “Equal Representation Act”) to mandate a citizenship question on the census and apportion based on citizens, claiming it would ensure only citizens influence representationcivilrights.orgcivilrights.org. This reflects a political calculus: Republican-leaning states stand to gain power if non-citizens (who tend to cluster in Democratic areas) are excluded. Our analysis shows those gains would be real, but relatively modest – still, in a closely divided House, a net swing of a few seats could be consequential. One immediate implication if such a policy were seriously pursued is that district maps and plans would have to be redrawn across many states. States losing seats (like CA or NY) would undergo another round of redistricting to collapse districts – a process likely to pit incumbents against each other and could weaken representation for fast-growing immigrant communities (e.g. California’s Inland Empire or New York City’s outer boroughs might see districts merged or eliminated). States gaining seats would also redraw maps to add new districts, which could reopen contentious gerrymandering fights (for instance, North Carolina’s partisan battle over maps would intensify with an extra seat to allocate). These disruptions so soon after the 2020 redistricting cycle could create political chaos and confusion for voters, who may see their district boundaries shift mid-decade. Historical and Legal Context Historically, the principle of counting all persons for apportionment has been the norm since the nation’s founding. The original Constitution (Article I, Section 2) mandated counting “the whole Number of free Persons” and “three fifths of all other Persons” (the latter referring to enslaved people) while excluding “Indians not taxed”thirdway.org. After the Civil War, the 14th Amendment was adopted in 1868 to count “the whole number of persons in each State”, eliminating the three-fifths compromise. Ever since, every decennial census has included citizens and non-citizens alike for apportionment purposespewresearch.orgpewresearch.org. This includes vast waves of immigrants in the late 19th and early 20th centuries – for example, millions of non-citizen European immigrants in 1890 or 1910 were counted, boosting states like New York and Illinois in those eras. There have been periodic proposals to change who is counted (in the 1920s, some suggested counting only citizens or only voters, and more recently proposals to exclude undocumented immigrants), but no such change has ever been implementedthirdway.org. In fact, Congress explicitly considered and rejected limiting apportionment to citizens when debating the 14th Amendment in 1866civilrights.orgcivilrights.org. The legal consensus has long been that apportionment must be based on total population. In Evenwel v. Abbott (2016), the Supreme Court unanimously upheld the use of total population in drawing state legislative districts, noting that representatives serve all residents (“the whole community”) not just eligible voters – by extension underscoring that representational equality in Congress is based on all persons, not just citizensthirdway.org. Earlier, in Franklin v. Massachusetts (1992), the Court affirmed the inclusion of overseas federal employees in state counts, reinforcing that “persons in each State” means literally every person with usual residence in the statethirdway.org. There is no constitutional provision or statute that excludes non-citizens from the apportionment count, and attempts to do so unilaterally have been deemed unlawful. Recent attempts to exclude certain groups underscore the legal barriers. In 2018, Alabama sued the Commerce Department to prevent counting undocumented immigrants, fearing the loss of a House seat to states like California. That lawsuit argued counting undocumented residents diluted Alabama’s representation, but federal courts dismissed the casein 2021brennancenter.orgbrennancenter.org, essentially for lack of standing and because the claim was not supported by law (the dismissal came after the 2020 census, rendering the issue moot for that cycle). The Trump administration in 2020 openly sought to alter the apportionment by first attempting to add a citizenship question to the census (blocked by the Supreme Court in Department of Commerce v. New York (2019)) and later issuing a presidential memorandum to exclude undocumented immigrants from the 2020 apportionment count. This effort was met with immediate legal challenges. While the Supreme Court in late 2020 punted on ruling directly (finding the issue not ripe, since the census results were not finalized), the plan never came to fruition. Career Census Bureau officials could not produce a reliable count of undocumented immigrants by the apportionment deadline, and the policy was rescinded by the incoming Biden administration. Notably, even some conservative justices hinted at skepticism of Trump’s authority to redefine “persons” for apportionment, and ultimately no apportionment excluding non-citizens has ever been carried outthirdway.org. In 2021, President Biden reaffirmed that the apportionment would include all residents, “without regard to immigration status,” restoring the traditional practice. Legally, to exclude non-citizens from apportionment would almost certainly require a constitutional amendment. A simple statute like H.R. 151 would face strong constitutional objections, as it directly conflicts with the 14th Amendment’s text and intentcivilrights.org. Amending the Constitution is a very high bar (needing two-thirds of Congress and 38 states’ ratification), making this change highly unlikely in the foreseeable future. Moreover, the census itself would need to reliably determine citizenship status for every person – something the Census Bureau has cautioned against. Adding a citizenship question or otherwise trying to identify non-citizens at a granular level could undermine the accuracy of the count, because it might deter responses not only from undocumented immigrants but also from mixed-status households and even some citizens (fearing consequences)civilrights.orgcivilrights.org. This could lead to an undercount and faulty data for all purposes (not just apportionment). In short, implementing a citizens-only apportionment is fraught with legal and practical challenges. Conclusion Excluding non-citizens from congressional apportionment in 2025 would significantly reshuffle House seats among the states – shifting representation away from immigrant-heavy states toward states with fewer immigrants. California, New York, New Jersey, and Illinois would lose seats, while states like Texas, Florida, and several others would gain. The net partisan effect would likely modestly help Republicans, as many of the lost seats would have been in Democratic strongholds and many of the gained seats would be in Republican-leaning areas. We estimate Democrats could lose roughly 3–5 House seats net under this scenario, slightly bolstering GOP margins. Such changes would have ripple effects on political power and resource allocation: immigrant-rich communities would have reduced representation and voice in Congress, and by extension less influence over federal decisions, while less diverse regions would gain influence. However, it is crucial to recognize that this scenario remains a hypothetical exercise. Under current law and constitutional interpretation, non-citizens must be counted in apportionmentthirdway.org. The proposal to exclude them clashes with a long lineage of law and practice upholding that congressional representation is for “all persons” residing in each state. Any attempt to implement a citizens-only count would face formidable legal challenges and likely be struck down as unconstitutional without an amendment. The debate, nonetheless, highlights the intersection of immigration and political representation: as the population of non-citizens is not evenly distributed, their inclusion or exclusion can alter the balance of power among states. This has made the census a contentious political issue in recent years. Moving forward, unless the Constitution is changed, the United States will continue the tradition begun in 1790 and reaffirmed in the 14th Amendment – allocating political representation based on the total population, inclusive of non-citizens, in the interest of equal representation for all communitiesthirdway.org. References: U.S. Census Bureau – 2020 Census Apportionment Results (official state populations and House seats)pewresearch.orgpewresearch.org. American Community Survey 2015–2019 – estimates of citizen and non-citizen populationsthearp.org. American Redistricting Project – “2020 Congressional Apportionment – Total Citizen Population” (analysis of House seat distribution using citizen-only populations)thearp.org. Center for Immigration Studies – “Tilting the Balance” (2024 report on immigration’s impact on apportionment; includes partisan lean analysis)cis.orgcis.org. Pew Research Center – “How removing unauthorized immigrants from census could affect House reapportionment” (2020 analysis of excluding undocumented immigrants)pewresearch.orgpewresearch.org. FactCheck.org – “Elon Musk Overstates Partisan Impact of Illegal Immigration on House Apportionment”(2024)factcheck.orgfactcheck.org. Third Way – “Is Illegal Immigration Really a Democratic Plot to Sway Apportionment?” (2024) – historical/legal discussion and review of researchthirdway.orgthirdway.org. Brennan Center for Justice – Alabama v. Commerce Dept. case summary (Alabama’s failed 2018 lawsuit on excluding undocumented from census)brennancenter.orgbrennancenter.org. The Leadership Conference – “Save the 2030 Census and Honor the Constitution: Vote No on H.R.151” (2025 fact sheet opposing citizen-only apportionment)civilrights.orgcivilrights.org. Electoral College Votes: Electoral College Reallocation if Undocumented Immigrants Are Excluded (2025 Census Scenario) The table below compares each state’s electoral votes in the 2024 election (based on the 2020 Census) with a revised allocation excluding undocumented immigrants from state populations. It also shows the estimated undocumented population in each state and the net change in electoral votes (House seats plus two senators) under the exclusion scenario: State Electoral Votes (2024) Undocumented Pop. (est.) Revised Electoral Votes Net Change Alabama 9 62,000migrationpolicy.org 9 0 Alaska 3 10,000migrationpolicy.org 3 0 Arizona 11 273,000migrationpolicy.org 12 +1 Arkansas 6 58,000migrationpolicy.org 6 0 California 54 1,800,000pewresearch.org 51 –3 Colorado 10 162,000migrationpolicy.org 10 0 Connecticut 7 113,000migrationpolicy.org 7 0 Delaware 3 24,000migrationpolicy.org 3 0 District of Columbia 3 21,000migrationpolicy.org 3 0 Florida 30 1,200,000pewresearch.org 32 +2 Georgia 16 339,000migrationpolicy.org 16 0 Hawaii 4 51,000migrationpolicy.org 4 0 Idaho 4 29,000migrationpolicy.org 5 +1 Illinois 19 400,000pewresearch.org 18 –1 Indiana 11 102,000migrationpolicy.org 11 0 Iowa 6 37,000migrationpolicy.org 6 0 Kansas 6 69,000migrationpolicy.org 6 0 Kentucky 8 46,000migrationpolicy.org 8 0 Louisiana 8 70,000migrationpolicy.org 8 0 Maine 4 5,000migrationpolicy.org 4 0 Maryland 10 225,000migrationpolicy.org 10 0 Massachusetts 11 209,000migrationpolicy.org 11 0 Michigan 15 91,000migrationpolicy.org 15 0 Minnesota 10 81,000migrationpolicy.org 10 0 Mississippi 6 25,000migrationpolicy.org 6 0 Missouri 10 50,000migrationpolicy.org 10 0 Montana 4 3,000migrationpolicy.org 4 0 Nebraska 5 42,000migrationpolicy.org 5 0 Nevada 6 168,000migrationpolicy.org 6 0 New Hampshire 4 11,000migrationpolicy.org 4 0 New Jersey 14 475,000pewresearch.org 14 0 New Mexico 5 63,000migrationpolicy.org 5 0 New York 28 650,000pewresearch.org 27 –1 North Carolina 16 296,000migrationpolicy.org 16 0 North Dakota 3 5,000migrationpolicy.org 3 0 Ohio 17 89,000migrationpolicy.org 17 0 Oklahoma 7 90,000migrationpolicy.org 7 0 Oregon 8 108,000migrationpolicy.org 7 –1 Pennsylvania 19 153,000migrationpolicy.org 19 0 Rhode Island 4 24,000migrationpolicy.org 4 0 South Carolina 9 88,000migrationpolicy.org 9 0 South Dakota 3 7,000migrationpolicy.org 3 0 Tennessee 11 128,000migrationpolicy.org 11 0 Texas 40 1,600,000pewresearch.org 41 +1 Utah 6 89,000migrationpolicy.org 7 +1 Vermont 3 3,000migrationpolicy.org 3 0 Virginia 13 251,000migrationpolicy.org 13 0 Washington 12 246,000migrationpolicy.org 12 0 West Virginia 4 4,000migrationpolicy.org 4 0 Wisconsin 10 70,000migrationpolicy.org 10 0 Wyoming 3 7,000migrationpolicy.org 3 0 Summary of Changes: Based on these projections, states with large undocumented immigrant populations would lose electoral votes, while several faster-growing states with fewer undocumented residents would gain. Notably, California(with an estimated 1.8 million unauthorized immigrants in 2022pewresearch.org) would drop to 51 electoral votes – 3 fewer than in 2024. This reflects California potentially losing two additional House seats on top of the one it already lost after 2020factcheck.orgfactcheck.org. New York (≈650,000 unauthorized in 2022pewresearch.org) and Illinois(~400,000pewresearch.org) would each lose one more seat, reducing them to 27 and 18 electoral votes, respectively. By contrast, Florida (≈1.2 million unauthorizedpewresearch.org) would gain about 2 extra electoral votes, reaching 32 total. Texas (≈1.6 millionpewresearch.org) would net +1 electoral vote, for 41 total. Several other states with relatively small unauthorized populations could pick up a seat – for example, Arizona (+1) and Idaho (+1) – due to their growing citizen populations and the reallocation of House seats from states like California and Illinois. Critically, some states would retain seats they might have otherwise lost. Pew Research Center’s analysis of the 2020 Census found that Alabama, Minnesota, and Ohio would each have lost a House seat if apportionment were based on total population including undocumented immigrants – but would keep those seats if undocumented residents were excludedpewresearch.org. Our 2025 scenario likewise shows no change in electoral votes for those states, indicating they hold onto their representation. For instance, Alabama and Minnesota remain at 9 and 10 electoral votes, respectively, instead of dropping to 8 and 9 as might have occurred if all residents were countedpewresearch.org. Overall, 13 states see a change in electoral votes under this exclusion scenario. The largest gainers are Florida and a handful of mid-sized states in the West and South, while losses are concentrated in a few high-immigrant states. Importantly, the total shift is modest – a net transfer of only a few House seats. Prior studies of the 2020 apportionment found that counting or excluding unauthorized immigrants would have changed only about 6 seats, with minimal partisan impactthirdway.orgfactcheck.org. Our updated projections similarly suggest a limited effect on the balance of power. The Electoral College outcome would not be dramatically altered – the changes (e.g. Florida +2, California –3) would not have swung recent presidential elections, given margins on the order of dozens of electoral votesfactcheck.org. However, the trend since 2020 indicates that migration is bolstering populations in many Republican-leaning states. Between 2019 and 2023, about 95% of noncitizen population growth (including undocumented immigrants) occurred in GOP-led states – especially Texas, Florida, South Carolina, and even Kentuckythirdway.orgcato.org. If these patterns continue, excluding undocumented residents from the 2030 census could actually benefit red-leaning states more than blue statesthirdway.orgthirdway.org. In our 2025 scenario, states like Texas and Florida gain slightly, while California and New York lose representation – consistent with the idea that high-immigration “blue” states no longer enjoy a one-sided advantage from counting undocumented immigrants. In short, removing undocumented immigrants from the apportionment count would shuffle a few electoral votes among states, but it would not radically change the Electoral College mapfactcheck.orgthirdway.org. The main effect is that fast-growing states with smaller unauthorized populations (e.g. Florida, Arizona, Utah) would pick up one or two extra votes at the expense of states with large undocumented communities (e.g. California, Illinois)pewresearch.orgfactcheck.org. The overall balance between the two major parties would remain virtually unchanged in this hypothetical 2025 reallocationthirdway.org. Sources: U.S. Census Bureau apportionment data; Pew Research Center estimates of unauthorized immigrant populationspewresearch.orgpewresearch.org; Migration Policy Institute datamigrationpolicy.orgmigrationpolicy.org; Ballotpedia (2024 electoral votes by state)ballotpedia.orgballotpedia.org; Third Way and Cato Institute analyses of immigration’s impact on apportionmentthirdway.orgcato.org; FactCheck.org reportfactcheck.orgfactcheck.org. The revised projections are calculated using the method of equal proportions with state population estimates as of 2025.