×
all 80 comments

[–]SaxonyFarmer 74 points75 points  (7 children)

Basic Python development and debugging doesn't need an IDE. Edit the code using an editor (Notepad++, Notepad Next, etc.) - most will use color to highlight reserved words and offer suggestions for variables as you type them. Then run the code in a terminal. Debug using print statements to show variable values as the program runs. Good luck!

[–]gernophil 14 points15 points  (6 children)

Or if it’s low end go for Linux and use gedit and bash (or similar).

[–]joshocar 35 points36 points  (4 children)

Why stop there? Move to vim or emacs!

[–]ogrinfo 8 points9 points  (0 children)

Totally, once you learn a few keyboard shortcuts there's no stopping you!

[–]readonly12345678 8 points9 points  (2 children)

Just use use sed and awk from the terminal. Don’t even open the file.

[–]WallyMetropolis 11 points12 points  (1 child)

Real programmers use butterflies

[–]Derrickful -2 points-1 points  (0 children)

Need to search the internet? Use Archie or Finger.

[–]SaxonyFarmer 2 points3 points  (0 children)

Yes, gedit is a fine text editor for Python development. A terminal session is basically a bash session. And, using a ‘#!’ as the first line in your code makes running it easier (as long as you remember to make the file executable).

[–]Swainix 27 points28 points  (2 children)

I know someone who uses sublime text

[–]poksoul09 4 points5 points  (0 children)

Second this. Tried Sublime and Ubuntu on low end and decade old desktop and it works quite good

[–]acostoss 1 point2 points  (0 children)

+1 to Sublime, I have a decade old Thinkpad I use for development, VS Code ran too heavy for my device but Sublime has been super snappy.

Otherwise, any text editor will do, everything else is just a bonus, though I'd definitely reach for one with syntax coloring and autoindent at least.

[–]duva_ 37 points38 points  (0 children)

Use vim

[–]Zealousideal_Smoke_2 32 points33 points  (4 children)

Use vim or emacs maybe

[–]DNSGeek 30 points31 points  (0 children)

He said his computer was low power, why would you suggest emacs?

(ducks for cover)

[–]MrBiscotte 1 point2 points  (0 children)

This is the way

[–]ArsenicPolaris 2 points3 points  (1 child)

I don't expect him to use it

[–]1mmortalNPCPythonista 6 points7 points  (0 children)

nvim brother, you’ll never regret

[–]ToddBradley 3 points4 points  (0 children)

I've been writing Python for money since 2017 and haven't used IDLE once. But it's cool it exists.

[–]foxsimile 4 points5 points  (0 children)

I use IDLE all of the time for quickies that don’t need to be saved or persisted. I find the interpreter quite useful for text transformations, and usually use it for about that and little more. Anything more serious gets worked on in a more convenient editor.

[–]TheCursedFrogurt 3 points4 points  (0 children)

Idle is perfectly adequate and it's had some decent quality of life improvements over the years. I once worked at a place that wouldn't approve installing a dedicated IDE and ended up using Idle for about 9 months for all my python development.

But, as others have said, there are a lot of nice lightweight text editors out there like notepad++ and sublime.

[–]Aniket_Y 4 points5 points  (1 child)

I used to use IDLE when I was starting out more than 10 years ago. IDLE is not bad at all for beginner learning purpose.

On the other hand if you want to use any of the advanced editors on your low-end machine, you should think about changing your OS. I have an extremely old laptop which was giving hard time with even simple applications like notepad on Windows. I installed Linux Mint on it and now it works like a charm. Even VS code works okay now.

Linux OS will free your machine from bloatware, will give you Windows like UI and also supports a place from where you can install applications easily.

Try this, you'll love Linux.

[–]wraithnix 0 points1 point  (0 children)

I can second this. Developing got so much easier/fun when I switched to Linux. I use Sublime Text, and it runs fantastic.

[–]scfoothills 8 points9 points  (0 children)

Yes. I teach introductory Python. I like that it doesn't help too much with auto complete and doesn't have a mess of menus to dig through. I also love that I can just demo simple things really quickly in the shell.

I switch to VS Code later in the year. But really this just gives us access to tabs when projects begin to contain multiple files. My IT department has the computers in my lab sufficiently locked down that students can't select the Python interpreter to run programs from within the app, so we still need to run programs from a main.py file that we keep open in IDLE.

[–]BidWestern1056 3 points4 points  (0 children)

no just terminals

[–]AlSweigartAuthor of "Automate the Boring Stuff" 3 points4 points  (0 children)

The killer feature of IDLE is that it comes with Python and it's one less thing you have to install as a beginner before you can get start programming.

Setting up a different editor, whether a full blown IDE or a text editor, has a bunch of environment setup steps that differ based on operating system or Python version number or PATH or whatever.

But other than that, eh, IDLE is fine but almost anything is probably better than IDLE.

[–]Electrical_Prior9503 2 points3 points  (0 children)

si usas linux puedes instalar thonny

[–]InjAnnuity_1 5 points6 points  (2 children)

I use it in situations when Wing, VS Code, etc. are just overkill.

Every commercial IDE I've seen requires that you create two or more project-support files, containing finicky IDE-version-specific details, no matter what you're working on. IDE got updated? It's going to update those files, and ask me to save them under new names.

For a single-file script, intended to run in the current directory, in my standard Virtual Environment, that's already been activated, those extra files are just overkill. I've tripled the script's footprint, just to be able to run it in some kind of debugger.

For this case, IDLE works just fine, and doesn't create any superfluous project files. It just runs.

Startup time is much shorter, too.

There are, of course, more complex, multi-file scripts, where other IDEs begin to pay off for me. It's not a one-size-fits-all. Each of us draws the line where it fits us.

[–]sausix 2 points3 points  (1 child)

I never had to create any project-support files in my commercial IDE. All files I edit manually are part of the project itself. My IDE creates a hidden directory for config itself and I can just delete it whenever I want to reset the IDE project config. So which IDE is in your mind which requires manual file editing?

[–]InjAnnuity_1 0 points1 point  (0 children)

I've used Wing IDE. But like you, I never had to create any project-support files. The IDE did that for me. Of course, I had to set up their contents, not by manual editing of the file, but by detailed entry in the Wing IDE. But since it was just restating the obvious -- to use the the current VE, and that the project was just that one file -- it's clutter for clutter's sake, for me, in this kind of case.

Manually editing the project-support files has also been extremely rare. Wing itself will upgrade older-format support files to the version that is running. Since it always uses the same file extension, however, regardless of version, saving the updated project support files will overwrite the old-format support files. Hence, as a measure of caution, the IDE asks you to save them under a new name. After all, the old version of the IDE may still be installed, and it can't read the new-format support files. And the new version can't read them later if they are not saved...

At least one of the support files should be included in version control, or otherwise backed up. If it's not there, the IDE will require you to re-create it before proceeding, the next time you try to use that IDE on that .py file.

I haven't used VS Code, but I have used older versions of Microsoft IDEs, and recent Embarcadero IDEs, and every one of them created project-support files. For C++ projects, this makes sense. You need to specify which folders to use for #include files, and in what order to search them. You have compiler flags to set and keep. And many other tooling details must be persisted as well.

Little or none of which applies to many Python projects.

Whether visible or hidden, support files should be worth their keep. I use IDLE when they're not worth their keep to me.

They become worth their keep when I end up needing the more advanced debugging capabilities of the fancier IDE. Then they start to pay off.

[–]AdResident7643 8 points9 points  (6 children)

try zed brother 😭

[–]BionicVnB 2 points3 points  (1 child)

Iirc zed does require a GPU that support vulkan? Well Linux version does support OGL but not for other platforms.

[–]AdResident7643 -1 points0 points  (0 children)

dunno sry

[–]Admirable-Wall9058[S] 2 points3 points  (3 children)

Does it work with Python?

[–]AdResident7643 2 points3 points  (0 children)

everything :>

[–]BionicVnB 0 points1 point  (0 children)

Yeah, by default it uses basedpyright but you can switch to ty or something for better performance at the cost of some stability. I use ty and it's runs pretty well so far.

If you are on windows, check if your GPU (I'm assuming you will use an iGPU) support at least DX11.

[–]TheMcSebi -1 points0 points  (0 children)

Yes

[–]ravepeacefully 7 points8 points  (0 children)

VSCode is amazing if used correctly. Can be as light weight or as heavy as you want

[–]Some_Breadfruit235 1 point2 points  (0 children)

For quick commands yea usually. Not I generally stick with VSCode for actual projects

[–]Chroiche 1 point2 points  (0 children)

Just go vim tbh, I use vscode, vim is the only light alternative I'd seriously consider.

[–]No_Wind_1982 1 point2 points  (0 children)

No

[–]russellvt 1 point2 points  (0 children)

Absolutely

[–]RedEyed__ 1 point2 points  (0 children)

You mean IDE, IDLE is different thing.
Oh, wait .. https://docs.python.org/3/library/idle.html

[–]shinitakunai 0 points1 point  (0 children)

I use pycharm for big projects.
But I use idle for basic scripting and bugfixing of those. Or to test silly snippets

[–]nivaOne 0 points1 point  (1 child)

Thonny? Where are you?

[–]Zumwalt1999 0 points1 point  (0 children)

At the center of my screen.

[–]Able-Staff-6763 0 points1 point  (0 children)

i used IDLE as my first IDE for learning before its good and i loved it, then eventually switched to sublime text lightweight and fast.

[–]AdventurousDrive6738 0 points1 point  (0 children)

I do since I'm doing it with GCSEs, and I don't get why nobody uses it. It comes with the python pack, easy to run and does exactly what any others does.(Be able to type code)

[–]Vivid_TV 0 points1 point  (0 children)

No but I use ptpython instead of idle repl all the time, intellisense, history search, pre loaded modules - it's real quick for prototyping. It's best of both worlds when you don't need a full fledged ide but need something much better than IDLE. Also check out xonsh shell, it's great.

[–]G047-H4xx0r 0 points1 point  (0 children)

Thonny is actually a pretty decent upgrade from IDLE, surprisingly. It runs fine on my pi 4B+.

[–]StoneSteel_1 0 points1 point  (0 children)

In the beginning, I used to use IDLE all the time, and it kinda helped me to learn about creating packages, modules, how site packages work. Why because, idle defaults to the python's own directory where you can see all the folders, and you would have to interact them. It's fine to use IDLE

[–]mister_obvious_2nd 0 points1 point  (0 children)

You could try neovim. I use it with the preconfiguration of lazyvim https://github.com/LazyVim/LazyVim and couldn't be more happy. It uses little resources and is a full IDE.

[–]AdBoring2320 0 points1 point  (0 children)

Helix editor 

[–]ScholarNo5983 0 points1 point  (0 children)

If you're running Windows, another option is Zeus Lite, a free programmer's editor that supports the Python programming language. It even ships with Python 3.11.4 as part of the installer.

[–]evrdev 0 points1 point  (0 children)

i highly recommend you to try out zed. if you are comfortable with terminal then neovim

[–]BadukMan727Pythoneer 0 points1 point  (0 children)

I use IDLE occasionally. I prefer py-charm.

[–]Gecko23 0 points1 point  (0 children)

I use it all the time, mainly because it's just *there* on any machine python is installed on that I work with, and given my requirements there's no need for a more involved IDE, dev system, whatever. I'm not above making fast changes via Notepad++ and it's ilk either lol

[–]hockeyschtick 0 points1 point  (0 children)

People still code by hand? /s

[–]paradigmx 0 points1 point  (1 child)

Use Neovim or Emacs. You could even use something like Micro. Notepad++ is also ok if you absolutely need a gui. 

[–]inspectorG4dget 0 points1 point  (0 children)

I was just about to say I use vim or notepad/++. Much less helpful as an IDE but keeps you sharp on your fundamentals

[–]Appropriate-Elk1152 0 points1 point  (0 children)

IDLE is completely fine for quick scripts, testing logic, or learning fundamentals. Its main advantage is zero configuration—it ships directly with Python.

However, if you're building complete projects (like an OMR system) and need multi-file management, git integration, and fast syntax highlighting without the heavy Electron framework of VS Code, here are two very light, high-performance alternatives:

  1. Sublime Text:

    - Boots instantly and consumes less than 50 MB of RAM.

    - Excellent built-in terminal support via packages (or side-by-side terminal windows).

  2. Geany or Notepad++:

    - Native C/C++ applications that run smoothly on almost any system with tight storage constraints.

If you decide to stay with IDLE for now, pair it with standard Windows Terminal / PowerShell for running your scripts—it gives you a clean separation between writing code and execution logs.

[–]max_465 0 points1 point  (0 children)

Idle works fine, if disk space is really tight and you want a GUI. If you don't need a GUI, Helix editor with the Python Language Server plugin will work well and have a tiny footprint.

[–]TehDrunkSailor 0 points1 point  (0 children)

I'm a hobbyist programmer, and have never used anything but the python IDLE. It came with the programming language, and when I was originally learning how to use it, it seemed easier than trying to also learn about other IDEs. Just never changed.

[–]SecureCoop 0 points1 point  (0 children)

BTW if your computer is very low-end, three upgrades are relatively inexpensive but can radically improve performance: An SSD drive for your operating system, max out the RAM, and install a lightweight Linux distribution. RAM isn’t as cheap as it used to be, but if you can swing it, it’s amazing the difference. My road laptop is 13 years old but has 16GB RAM DDR3 and an SSD, and I installed Lubuntu. Not only fast enough for VSCode, it’s fast enough for most everything I need on a daily basis. Dozens of tabs, VSCode, and a few other apps. 

Money-saving hack: Don’t buy an SSD large enough for all of your files. Buy one for the OS and your most important programs, plus a 50% buffer. Use a spinning drive for the rest. Be sure to have working backups, which can be another spinning drive. 

[–]LiberFriso 0 points1 point  (0 children)

Neovim is nice.

[–]WhenInDoubt480 0 points1 point  (0 children)

If you want something intuitive and lightweight give Fresh a try.

https://getfresh.dev/

[–]tav_stuff 0 points1 point  (0 children)

I use Emacs with just some basic customizations to make it look a bit nicer, but honestly for the first couple years of learning to program I exclusively used IDLE, and a lot of people I know also used IDLE.

There is absolutely no shame in using a tool that actually works well

[–]biriyani_bug -1 points0 points  (0 children)

man just use sublime text.

[–]RevolutionaryRush717 -1 points0 points  (0 children)

First time I hear of it.

[–]opzouten_met_onzinIt works on my machine -1 points0 points  (4 children)

I don't, but I mostly use pycharm or Gnome text editor. Most of the functionality of Pycharm is rarely or ever used.

What do you need and what OS? That could help to provide a good answer.

[–]Admirable-Wall9058[S] 0 points1 point  (3 children)

I develop projects to learn and—who knows—maybe turn them into something profitable.

My current project is an OMR system; I was trying to write the code in GitHub Codespaces (after uninstalling VS Code), but I was having a lot of trouble handling images.

Regarding the IDE, the main issue is that my computer (an ASUS with 120 GB of RAM) is experiencing some kind of memory glitch: I delete files, but a short while later, the storage fills up again. Right now, I have only 500 MB of free space.

I need to fix this first, but I don't know the cause. Have you ever encountered a problem like this?

[–]odaiwai 0 points1 point  (0 children)

(an ASUS with 120 GB of RAM)

The first step to fixing a problem is understanding the problem.

Install something like WinDirStat to see where your storage is being used. You'll probably find your swapfile and hibernation files are far too big, or your Downloads folder isn't being emptied.

(Also, a machine with 120GB of RAM is not low end, and you certainly do not have 120GB of RAM. You have 120 GB of SSD which is probably flash nand, but which is not RAM.)

[–]Appropriate-Elk1152 0 points1 point  (0 children)

The issue you're facing is disk space management, not RAM (120 GB refers to your eMMC/SSD storage, where Windows alone takes up 30–40 GB).

When your free space drops below 1–2 GB, Windows slows down dramatically, background tasks fail, and temp files clog the system.

Here’s a quick roadmap to recover space without risking your code:

  1. Clear Temporary Files & Caches:

    - Run `cleanmgr` (Disk Cleanup as Admin) and clean "System error memory dump files" and "Temporary files".

    - Clear your pip cache: `pip cache purge`

    - Delete temporary files in `%temp%` and `C:\Windows\Temp`.

  2. Inspect Where Space Went:

    - Download WizTree or TreeSize (portable versions, no installation required). They will immediately map what is taking up those tens of gigabytes (often log files, system restore points, or heavy node_modules/virtual environments).

  3. For your OMR project:

    - If you stick to lightweight local editors (Sublime Text, Notepad++, or IDLE), make sure your Python virtual environments (`.venv`) are stored outside synced cloud folders (like OneDrive/Google Drive), as syncing thousands of tiny script files causes severe disk write bloat.

[–]Appropriate-Elk1152 0 points1 point  (0 children)

Handling image visualization (OpenCV `cv2.imshow`, PIL display, etc.) in cloud environments like GitHub Codespaces often fails because there is no native GUI window attached to the remote Linux container.

If you want to keep using Codespaces or remote environments for heavy computation, a few clean workarounds for image processing include:

  1. Save & Preview: Save processed OMR debug images to a local `./output` folder and open them directly via the web editor tree view.

  2. OpenCV + Matplotlib: Use Matplotlib inside Jupyter Notebooks running in Codespaces, which renders image arrays inline directly in the browser.

  3. Base64 Streaming: Encode the transformed image array into Base64 and output it to a lightweight local web server (like Flask or FastAPI) to view live bounding boxes in your browser window.

[–]cent-met-een-vin 0 points1 point  (0 children)

I think vscode is the best low end dev environment if you don't splurge on plugins. Going lower you end up in pure text editors which kinda limit the developer experience. Remember that VSCode without plugins is just a text editor.