Wing IDE Review: Features And Advantages

A Comprehensive Review of the Functionalities, Advantages, and Features of The Wing Python IDE:

Wing is a Python IDE (Integrated Development Environment) that aids development activities with functionalities like intelligent editing, debugging and code navigation.

It is a software setup that combines the mechanisms required to Code and Test Software applications.

Wing IDE

Wing IDE: A Complete Overview

What Is An IDE? Why Is It Required?

An Integrated Development Environment(IDE) brings many of the development tools like editors, libraries, compilers, and platforms together as a single framework. Developers often use multiple tools while creating, building and testing software code.

Without an IDE, the developer will have to identify, set up, integrate and administer all of these tools individually. IDE is designed to eradicate the need for multiple tools and also help in identifying and reducing mistakes made during code creation and implementation.

Why Wing IDE?

Wing is a Python-specific IDE that offers several outstanding benefits as listed below.

  • Intelligent Editor
  • Easy Code Navigation
  • Powerful Debugger
  • Integrated Unit Testing
  • Remote Development
  • Customizable and Extensible

We will explore these benefits in the next section.

Advantages Of Wing IDE

A detailed explanation of each advantage of Wing IDE has been given below.

#1) Intelligent Editor

Wing’s editor enhances Python development by making it more interactive with context-appropriate auto-completion & documentation, auto-editing, invocation assistance, code folding, refactoring, multi-selection, customizable inline code snippets, and bookmarks. Wing can emulate other editors like vim, Eclipse, Emacs, Visual Studio, and XCode.

Its Major Characteristics Include:

(i) Solid Editor Basics

The Editor supports features like configurable tabs & split windows, indentation assistance, code folding, error indicators, visit history, flexible selection modes, editor emulation, and auto-save.

Over 70 odd languages are supported. Open files can be selected either with a pop-up menu or with tabs at the top of the editor. The editor can be split into any number of parts, horizontally or vertically. As you type, Wing indents automatically based on the context in the source code.

The Editor matches braces by highlighting them as you type. Wing IDE’s editor supports folding up code based on its structure as a way to view the top-level contents of a file or class and then drill down into the point of interest.

You can fold up individual functions using the folding margin, collapse a definition completely and then expand it incrementally or fold up all the methods or classes for a view of the top level of a module.

Solid Editor Basics

(ii) Intelligent Auto-Completion

Wing’s auto-completer uses both static and runtime analysis to provide context-appropriate completions in the editor and integrated Python shell.

The source assistant updates as you move around the editor, auto-completer, and other parts of the IDE to show documentation, information about object inheritance, call signature, and links into Python documentation for built-ins and standard library.

For blocks like ‘try’, the wing automatically adds accept and lets you add the exception type or convert it to a try-finally block.

Intelligent Auto-completion

(iii) Auto-Editing

A suite of Auto-Editing operations further simplifies coding, For Example, Wing auto enters arguments when you type and invocation allows you to tab through the argument list. Wing automatically removes any unaltered defaults when you leave the invocation.

You can also easily modify blocks of code by selecting arrange of lines and pressing the colon key for creating a new block with those lines. Alternatively, press the colon key repeatedly to move the next line or contiguous range of lines under a new block.

Other auto-editing options include auto-indentation, auto-spacing optionally in pep8 style, and auto-correcting out-of-order typing. When a file with mixed indentation is opened or if a file contains indentation errors, the Wing can optionally warn about the file and offer to repair and convert its indentation.

When indentation errors exist in the file, the indentation tool displays buttons that can be used to find and repair the errors. There is even an optional turbo completion mode for Python where every non-symbol key becomes a completion key depending on where you are typing and what key you are pressing.


(iv) Refactoring

Refactoring helps in reordering the code without affecting its functionality. Moving the point of definition and renaming symbols, creating a function or method from an existing code, adding a variable for expression, and updating the style of symbol naming are supported by Wing.

Wings refactoring tool reorganizes code without introducing errors.

You can rename all the users of a symbol without getting confused by other symbols that happen to have the same name. You can extract code by selecting a range of code and making it into a new function or method. You can introduce variables for expression and you can move symbols around by automatically updating any points of use.

Selecting code for refactoring and other edits is easy by using the control up arrow and control down arrow to select code in logical units.


(v) Multi-Selection

Wing supports making multiple selections of the same expression within a block, file or scope by clicking on the editor and applies changes uniformly to the selections.


(vi) Code Snippets

Wing supports rapid entry of universal code templates and most used structures from the editor’s auto-completer, offered in the form of code snippets entered by tabbing through the code. Snippets can take various forms based on the invoking context.

Code Snippets

#2) Easy Code Navigation

Wing uses runtime and static analysis to understand and navigate through complex or unfamiliar code. You can get around code easily by typing a fragment of a file or symbol name by using the code index menus or from the source browser.

(i) Go to the definition and Find Symbol

The Wing moves to a symbol’s point of definition from any use of the symbol in the editor. Wing IDE makes it easy to jump to the point of definition of a symbol in the Python source code by control-clicking on it, pressing F4 or right-clicking, and selecting ‘Go to Definition’.

The Editor contains symbol index menus for navigation inside a file. The Find Symbol and Find Symbol in the Project boxes help to search a symbol’s definition by typing fragments of a symbol. The back and forward visit history buttons at the top left of the editor can be used to return from or revisit the point of definition.

Go to -Definition and Find Symbol

(ii) Find Points of Use

Wing navigates and inspects the usage of a symbol in the code of a project or in a given path. Wing can search for and display points of use of source symbols in the editor. Only true uses of the symbol are shown and not other symbols that happen to have the same name.

Clicking on the ‘Uses’ tool brings up the point of use in the editor. Right-clicking can find all points of use for a symbol in any module of your project or any code that you import.

Find Points of Use

(iii) Source Browser

The Source Browser helps you to navigate the whole code by module or class hierarchy in the current file or the whole project. It displays a source index which makes it easy to navigate through code in the current file or project.

The structure of the file is shown along with the types of symbols, whether they are imported or inherited and whether they are private to their scope.

The display can be filtered to omit certain types of symbols or those that are inherited or imported. The source browser can also display symbols for all packages and modules in the project and it provides a view that lists all classes found in the project or on the Python path.

Source Browser

(iv) Powerful Search

You can search and replace code in a file, directory, or all project files with functionalities like text matching, regular expressions, or wildcards. Wing provides convenient search interfaces for different search tasks. The toolbar search is a quick and easy way to search for a simple text match within the current file.

Keyboard-driven mini search in the Edit menu is a more sophisticated way to search for text and regular expressions in a single file. The search tool implements a familiar graphical user interface for single file text, wildcard, and regular expression search and replace.

The search in file tool’s powerful multi-file searches and replace capability allows searches to operate on all files in the project, all open files, or within a selected directory.

The set of file searches can be constrained with file filters and there are a variety of other options for the style of search and altering the result display list. The search in file tool includes multi-file replace using a regular expression, and group matching and can also be used to search through Wing IDE’s integrated documentation.

Powerful Search

#3) Powerful Debugger

Wing’s Python Debugger was modeled to fix and isolate bugs and interact development of code. The Wing can debug any Python code regardless of how it is launched or whether it’s running locally or on another machine.

The Debugger is compatible with the code launched from IDE, run by a web framework or server, invoked as a script in an embedded copy of Python, or executed on a remote host. You can also debug Django templates and unit tests run from the Wings integrated testing tool.

(i) Solid Debug Basics

Wing allows you to set breakpoints to stop your code in the editor or Python Shell. Once you reach a breakpoint or exception in the Debugger, you can inspect the program state from the stack data tool or you can interact in the debug probe which is a Python shell that works in the current debug stack frame.

Wing shows debug data values when the mouse hovers over symbols in the editor and there is a watch tool for watching expressions or values over time, either by symbolic name or by object reference. Wing IDE can debug not only Python code but also Django template files.

You can start Django in the Debugger and use a browser to load a page that invokes the template.

You can use the Wing’s Debugger facilities both in any Python invoking the template or invoking by the template or the template itself. Wing replaces the Python stack frames in the Django template engine with stack frames based on the template context data and template stack.

The Debug probe is useful for interacting with the template’s data in the paused debug process. While the Debugger is active the COG icon in the editor’s auto-completer indicates that the completion is also being fueled by the live runtime state in the template engine.

Solid Debug Basics

(ii) Move Program Counter

Move Program Counter backtracks the current line of code execution so that you can go back and step over a failing code without restarting debug mode. The Debugger can move up and down the stack or step into or over function and method calls. If you step past the point of interest, you can click on any line in the bottommost stack frame and move the program counter.

Move Program Counter

(iii) Conditional Breakpoints

Conditional Breakpoints are used when a code is called multiple times, to identify and fix bugs affecting a specific part. Conditional Breakpoints make it easy to isolate a particular failing case to repeatedly invoke the code.

Conditional Breakpoints

(iv) Debug Command Line

Wing’s Debug Probe is an auto-completing Python shell that runs in the context of the current debug stack frame. It inspects and interacts with data at runtime to understand a bug and complete a fix.

You can immediately try out new code in the debug probe or by evaluating ranges of code from the editor within the integrated Python shell. This is a useful way to test out or play with the code or to work through designing a fix for a bug.

Debug Command Line

(v) Interactive Development

The Editor and Debugger work together to make the code intelligence features take advantage of the live runtime state. Running to a breakpoint is a great way to write a new code with direct access to the live runtime state. The Debugger is integrated with unit testing features to make the interactive development test-driven.

Interactive Development

(vi) Recursive Debugging

Recursive Debugging allows you to debug the code when at a breakpoint or exception during a debug session.

Recursive Debugging

(vii) Remote Development Debugging

Remote Development support can launch remote code from IDE. The Wing can be configured to debug code launched on a remote host.

Remote Development Debugging

#4) Integrated Unit Testing

Wing provides a Test-Driven Development approach like unit test, doc test, py test, and Django testing frameworks. Integrated with the debugger, the process is quick and efficient.

(i) Managing Unit Tests

Wing IDEs testing tool can be used to collect and execute unit tests in your project. Unit Tests can be created as individual files or selected using regular expressions or wild cards applied to the project contents. Tests can be run altogether, one at a time or through filtering.

When tests are run, results are shown in the testing tool, and clicking on a result shows the test in the Editor. Failed tests can be prioritized. Results include the date, running time as well as any exceptions or errors raised by the test. A summary of test results can be copied and pasted for sharing with team members.

Managing Unit Tests

(ii) Debugging Unit Tests

Wing’s testing tool supports running tests in its Debugger as a way to quickly diagnose and fix problems revealed by Unit tests. By defining and running tests to a breakpoint, new code can be written and tested in the context of the live runtime state, saving editing and testing rework time.

Debugging Unit Tests

(iii) Flexible Test Invocation

Launch configurations are used to run and debug tests in custom environments. To increase the speed of execution, multiple testing processes can be run concurrently in a module or package. Unit tests can also be run outside Wing and the results can be imported later.

Felxible Test Invocation

#5) Remote Development

Wing supports remote development where the Python code can be run on a remote host, container, or virtual machine with secure access to all of the Wing’s features.

(i) Easy Access to Remote Hosts

Remote Host is quick-to-configure and can be accessed by SSH. Wing’s Python Shell and OS Commands tool helps in running Python and other commands on the remote host.

Easy Access to Remote Hosts

(ii) Flexible Project Managing

Project files stored on multiple systems and remote hosts can be accessed using Wing.

Flexible Project Management

(iii) Remote Debugging

Wing extends all the debugging functionalities for remote debugging like stopping at breakpoints and exceptions, inspecting data, and stepping through code. X11 forwarding supports debugging code that displays windows, by moving the windows to where Wing is hosted.

Remote Debugging

#6) Customizable And Extensible

Wing’s display, as well as features, is configurable.

(i) Adjust Interface Layout And Color

The user interface can be configured with options to adjust the position of Editor splits & toolboxes, menu & toolbar content, color, fonts, and syntaxes. Wing can arrange the editor and tools provided by the IDE within a single window or in two multi-window modes. The toolbar colors and many other configuration options are also provided.

Tools can be moved from panel to panel and multiple instances of the same tool can be created. The editor area can be split arbitrarily or joined back into a single editor view. Tool panels can also be divided into multiple splits. Both the editor and tool can also be moved from panel to panel or out into a separate window.

The tool areas can easily be hidden and displayed with the F1 and F2 keys and shift F2 maximizes the Editor area.

Adjust Interface Layout and Color

(ii) Customize Functionality

Wing can emulate Visual Studio, vi, Eclipse, XCode, and emacs. Features can be enabled/disabled and configured to behave as desired.

Customize Functionality

(iii) Extend Wing With Python

Wing provides a scripting API that makes it possible to extend the IDE by writing Python scripts. Python scripts provide the functionality to both menu bars and tools in editor and project context menus.

You can debug and develop Wing using Wing. The places where the wing looks for extension scripts can be configured in preferences. Scripts act much like built-in IDE commands and can be assigned to key bindings.

Extend Wing with Python

Most Useful Feature: Debugging

Once Wing reaches a breakpoint or exception, you can step through your code line by line, optionally stepping into or stepping out of a function or method call. Hovering over symbols in the editor displays the current value of that symbol if it is active on the stack.

The stack data tool shows locals and globals for the current stack frame and can expand compound values to view their parts. A similar tool displays the modules that have been loaded by the debug process and allows inspecting any data that has been stored in them.

Wing can also watch the value of symbols as you step through your code. This can be done by the name of the symbol or you can watch a particular instance by its object reference.

The ladder allows watching a value even if the symbol was bound to go out of scope. Wing also makes it possible to change values during Debugging which can be useful in some cases to try out how their live code will behave with different data.


Wing IDE provides various useful features like a built-in Debugger, Debugging in threads, checks for errors in the source code, exceptionally responsive support, super-flexible macro capabilities, customizable plug-ins, and is totally worth the price.

Also, read =>> How to implement Stack in Python

Are you ready to try Wing IDE?