Integrate VB6 with the VB6.5 IDE.

Featuring the VBA SDK v6.5 + Automatic interop with VB.NET & VB6Backporter

A skeptic will question claims, then embrace the evidence.
A denier will question claims, then reject the evidence.

—Neil deGrasse Tyson 

  • How many other clones are there of VB6's IDE, with full intellisense, debugging, pre-compiling, etc.?
  • How many other clones  provide 100% core-language parity with the Visual Basic language?
  • How many other clones operate in the same memory space as Visual Basic?
  • How many other clones offer additional language features that extend the language into the modern era?
  • How many other clones  claim "zero" bugs in the IDE/VBE?
  • Which of these clones is the fastest at manipulating and managing code modules?
  • How many milestones were delivered on time, exactly when the developer projected them to be complete?

Benefits of Visual Basic for Applications (VBA)

"When you host Visual Basic for Applications inside your application, you provide your users with the full power of Microsoft Visual Basic. The key technology that makes individual Windows applications programmable and also makes it easy for your users to create integrated solutions is the Component Object Model (COM) technology known as Automation (formerly called OLE Automation). Automation allows a developer to use VBA code to create and control software objects exposed by any application, dynamic-link library (DLL), or ActiveX® control that supports the appropriate programmatic interfaces."

The Visual Basic Editor (VBE)

"The Visual Basic editor provides you with the ability to create, modify, and debug code behind the application document. This integrated development environment exists outside the host application window, enabling developers to write code in VBA and simultaneously view the results of their programming in the host application. Although the Visual Basic editor exists outside the application window, it runs in the same memory space as its host, thereby benefiting from tight integration for event handling as well as enhanced performance."
 - Microsoft Visual Basic for Applications 6.0 Software Development Kit Version 6.4/6.5 Welcome Guide 

Background history 

The final application host with intrinsic functions to compile native applications was VB6 with VBA 6 embedded as the front end UI editor (VBE 6).  However, Visual Basic Editor 6.x continued to be refined and compatible until 2007 with Visual Basic 6.5 (VBA 6.5 w/VBE 6.5).  Then, in 2010 VBA 7/VBE 7 received 64-bit support, but no additional features were added.  In 2013-2016 there were very few changes to Visual Basic with VBA 7.1/VBE 7.1.   Although, Office for MAC was brought back in 2016 with a couple minor updates to VBA including a sandboxed environment by default.

Then, the first working IDE clone prototype was released on 10/31/18 as announced, after only one month of development.  It was called VB6Backporter.exe, and it was written in VB.NET to handle VB6 projects.  Just 2 months later, an early BETA of the Visual Basic 6.5 IDE (VB65.exe) was released on 12/31/18, written with VB6.  It was actually backported to the VB6 format by/from its own code content (VB6Backporter.exe). There were only minor conversions left over that needed to be written by hand, so it saved a lot of development time overall.  It took 2 months because the VBA SDK had to be integrated with VB6 project formatting, and filtered out for any unused VBA project formatting and unrelated menu items.  The IDE wasn't as easy to customize as it should have been though, because in some cases you want to override the function and not tangle it up with the same name.  Finding built-in controls by their id yields the best results, but in some cases you must find by index.  Finding by name can fail sometimes for no reason at all, so it is not recommended if it can be avoided.

Visual Basic 6.5 IDE (Latest version updates 6/23/19) 

The integration classes included with the VBA SDK have now been heavily modified to emulate VB6's intrinsic features.  VB65.exe acts as the host application, with VBA embedded inside of it, sharing the same memory space.  Visual Basic 6.5 can create, open, edit, and save project (.vbp;.vbg;.bas;.cls;.frm) files.  It can also add/remove references and components.  The intrinsic functions of VB65.exe automate the compile process to build executable files in native or p-code format, provided that a licensed copy of Visual Basic 6.0 is installed.  The layout of the development environment and its features are nearly identical to that of VB6, except that the IDE has now been updated with modern icons and the newest features of VBA's IDE/VBE.    
Menu items can be dynamically customized by the developer with a lot of flexibility. 
Mouse-wheel and touch-pad input is automatically supported out-of-the-box.
This enhanced IDE is now flexible enough to implement all sorts of updates, since we have direct access to the object model and the events of VBA's IDE/VBE.  

  • Automatic "Pretty listing (reformatting)" is a great time saving feature similar to the VB.NET option.
  • Automatic insertion of end constructs, ie End If (optional).
  • Automatic insertion of close constructs, ie "" (optional).
  • Automatic initialization of dimensioned variables to be used as a quick constructor (optional).
  • Code folding allows developers to collapse and expand procedures, by right clicking the desired procedure and then selecting "Toggle Procedure Expansion" (optional) - does not work with numbered lines.  This will be updated so that an error handler will display the procedure name and line where the error was generated.
  • Toggle All Code Procedures (optional).
  • Any project changes outside of the code editor cause a warning message to be displayed, and there is an option to reload the external project changes, or keep the current project and re-save any open projects that may of been affected (optional).
  • An "Auto Syntax Check" notification is displayed in the menu bar to show any errors entered (after return key) on the previous line.  Visual Basic's "Auto Syntax Check" option can be turned off and overridden by the host application.  For example, the new syntax check actually checks to see if the last line called is a valid function or sub procedure, where the internal checker would allow an invalid or misspelled function/sub to be entered without any error notification at all.  This layer in between the code editor and the compiler will open up many possibilities for a Visual Basic hybrid language largely compatible with Visual Basic 6, VBA 6.5, and VB.NET 2005 through optional Interop.

Development path

In 2004, Microsoft advertised the ability to create your own customizable VB6.0 IDE with this SDK.  We plan to hook up the intrinsic functions of VB6 to duplicate the look and feel as close as possible with the newer user interface [Complete].  Then, we will add extensive customizations to the IDE feature set and the process of compiling applications [Progressed].  A layer between the IDE UI and the compiler will be created to allow Visual Basic's Auto Syntax Checker to be overridden [Started].  Code input that normally would be rejected by the syntax checker can now be accepted by this visible UI layer [proto-typed].  At compile time, this layer is converted to extend functionality or optimize code execution, and input that normally might be accepted can be rejected or transformed to be more efficient [partially implemented].  At present, there are a few missing features that are still under construction.  

Options planned for 2019

  • VB6 Namespace class templates will emulate their .NET counterparts (see below).
  • Manual and automatic removal of un-instantiated and unused classes before making a compiled executable file.
  • Developers will be able to design VB.NET forms and add VB.NET components, including seamless interop access to the control's event handlers.  We can achieve this with Interop Forms Toolkit 2.0.  Support for VB.NET controls will have an option to catch the events of a .NET control by its VB6 name, or with its NET equivalent name (if any vice versa).
  • Work is being done to support some of the additional VB6 file formats that are missing from VBA, i.e. ctl, pag, and res, however only a little bit of progress has been made, but there is hope of limited support still.  An upgrade conversion is recommended for UserControls, to take advantage of the richer .NET versions and the new Threading Model.  A VB6 UserControl and a VB6 ActiveX Control is now equivalent to a .NET UserControl.  A VB6 ActiveX DLL is equivalent to a .NET Class Library.  A VB6 UserControl used in Web applications is equivalent to a .NET Web Control Library.
  • Full class properties are not available in VBA, so those VB6 code module properties will have to be handled by the host application. At present, a default header is written to the class files and other types of code modules.  A solution to this may be more involved than originally thought.  Progress on this may be delayed.

Options planned for 2020+

  • We will prepare for native compiler support by porting VB6 code forwards and backwards, to learn every interchange possible in both directions.  The Visual Basic Back-porter (written in VB.NET 2005) will now act as the host with VB65.exe embedded inside.  Full input and output of the VB65 IDE can be managed within this NET application.  However, this application may or may not be integrated with a stand-alone version of VB65.  We may also utilize Visual Studio Tools for Applications (VSTA) in the process.
  • An option to choose the preference of VB compilation (native; p-code, or IL/CLR with modern language features and 64 bit capability). *
  • An option to view and synchronize the two code editors side by side, instantly verifying that the code conversions pre-compile/parse at design time.  The syntax checker will need subsequent updates of course.
  • A complimentary option to choose the preference of VB code editor style (VB6 or VB.NET).
  • The developer's preference of syntax (vb6 or may also be an option.  Some VB.NET keywords and features can compile to native code or p-code.  This will be fun to compliment the current VB syntax with VB.NET syntax.  For example, the "AndAlso" and "OrElse" keywords can supersede the "And" and "Or" keywords of VB6, since they execute in a superior way.  They "short-circuit" if any of the evaluations make the statement possible or not, rather than evaluate each and every condition regardless.  This strategy allows the developer to place the quickest expressions first, and the longer function calls or procedures after.  The slower expressions will execute only if the the earlier conditions have not short circuited the statement.  The keyword "AndAlso" will short circuit if a condition is false.  The "OrElse" keyword will short circuit if a condition is true. Similar features are also planned to improve the syntax closer to VB.NET standards without interfering with current syntax.  
  • A secure desktop environment will strengthen the security and integrity of the development process and the applications made within it.  Security was not an afterthought, the environment has already been developed, awaiting the final implementation.

VB6Namespaces (Optional - planned for 2019)

VB6Namespaces are a group of classes written in VB6, to duplicate VB.NET functionality.  They will become available as project templates, or they can be automatically instantiated at design time.  These private classes are nested so that the developer can call on them in the same way that they would in a VB.NET IDE.  They are similar to VB.NET Namespaces, but there isn't a need to reference a DLL.  At compile time, any unused or un-instantiated classes are to be excluded from the being compiled into the executable.  In fact, this is what the new IDE was developed to handle automatically when the build process starts.  Developers can get a fair portion of VB.NET code to compile in a VB6.x IDE, since many of the common Namespaces have duplicate classes visible within the scope of the project template chosen.

VB.NET Namespaces can also be directly accessed via interop.  This will become available in the backporter version at some point.  Basically, during the build process, before the VB6 application is compiled by VB65, the VB.NET application will search for Namespace scopes in the code and it will dynamically create the appropriate VB.NET assemblies for interop use.  The VB6 application will then access these via interop, by typing in the desired Namespace and desired parameter.  Pointer classes will be included in the VB65 project by default, that way the developer can use the intellisense and simply insert parameters.  This is a direct way to bring the full power of VB.NET controls and Namespaces to VB6/VB65, without really complicating the development process.






"Visual Basic for Applications, or VBA, is a distinct technology commonly used for application automation and macros inside of other applications, most commonly inside Microsoft Office applications. VBA ships as a part of Office and therefore the support for VBA is governed by the support policy of Office. However, there are situations where VBA is used to call or host Visual Basic 6.0 runtime binaries and controls. In these situations, Visual Basic 6.0 supported runtime files in the OS and the extended file list are also supported when used inside of a supported VBA environment.  For VB6 runtime scenarios to be supported inside VBA, all of the following must be true:

  1. The host OS version for VB runtime is still supported.
  2. The host version of Office for VBA is still supported.
  3. The runtime files in question are still supported."

- Support statement for Visual Basic on Windows, 1/17/18   


Installation of Microsoft Office is not required for the IDE to work.  The VBA SDK's for version 6.1 through 6.5 do not have a time limit imposed on the license for integrating, evaluating, and testing embedded VB projects. The applications that are ultimately created are made with a licensed copy of VB6 installed on the developer's machine.  Interestingly, the VBA SDK version 6.0 has a 60 day time limit and can only be installed on 5 devices.

"Effective July 1, 2015, Microsoft will no longer be requiring payment or reporting of royalties for those customers with VBA and/or VSTA Licenses. " -  Summit Software Company, FAQ about VBA SDK Support, 2018, 



VB65 (Requires VBA SDK and VB6) - Run As Administrator