New Executable - Revision history

Dr. Shuppet: /* Reorganized history section */

2023-01-30T15:55:33Z

Reorganized history section

← Older revision		Revision as of 15:55, 30 January 2023
Line 8:		Line 8:
	== History ==		== History ==

	The New Executable format was created in 1984 for MS-DOS and Windows<ref>Windows 1.0 DR4 from August 1984 features a format with .MOD extension; DR5 introduces a new format with NE bytes in the header and EXE2MOD utility renamed to NE, strongly suggesting this is the first appearance of the NE format.</ref>, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format with a mandatory MZ stub and an NE header offset field, still incompatible with newer versions.		The New Executable format was created in 1984 for MS-DOS and Windows<ref>Windows 1.0 DR4 from August 1984 features a format with .MOD extension; DR5 introduces a new format with NE bytes in the header and EXE2MOD utility renamed to NE, strongly suggesting this is the first appearance of the NE format.</ref>, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel.

	Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. It is also the version described by old versions of newexe.h, as distributed in the early MS OS/2 SDKs, and the CHS release of Word for Windows source code. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.		It first appeared in Windows 1.0 DR5, dated October 1984. Some, but not all of the files in DR5 contain an MZ stub. The format is quite different from its later versions, for more information, see [[New Executable (Windows 1.0 DR5)]].

			The next year, Windows 1.0 Alpha introduced an improved version of the format with a mandatory MZ stub and an NE header offset field, still incompatible with newer versions.

			Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. It is also the version described by old versions of newexe.h, as distributed in the early MS OS/2 SDKs, and the CHS release of Word for Windows source code.

			Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.

	Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change. IBM OS/2 Developer's Toolkit has newexe.h describing this version of the format.		Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change. IBM OS/2 Developer's Toolkit has newexe.h describing this version of the format.
Line 27:		Line 33:

	NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE<ref group="note">The name likely comes from Multitasking DOS 4, where the New Executable format first appeared.</ref> or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE (variously known as Segmented-Exectuable Linker and Linker/2) and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).		NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE<ref group="note">The name likely comes from Multitasking DOS 4, where the New Executable format first appeared.</ref> or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE (variously known as Segmented-Exectuable Linker and Linker/2) and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).

			During the development of the NE format, a different approach was used.

	== Reverse engineering ==		== Reverse engineering ==

Dr. Shuppet: /* Added more information about early history */

2023-01-30T14:17:02Z

Added more information about early history

← Older revision		Revision as of 14:17, 30 January 2023
Line 8:		Line 8:
	== History ==		== History ==

	The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format ~~and~~ a mandatory MZ stub, still incompatible with newer versions.		The New Executable format was created in 1984 for MS-DOS and Windows<ref>Windows 1.0 DR4 from August 1984 features a format with .MOD extension; DR5 introduces a new format with NE bytes in the header and EXE2MOD utility renamed to NE, strongly suggesting this is the first appearance of the NE format.</ref>, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format with a mandatory MZ stub and an NE header offset field, still incompatible with newer versions.

	Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. It is also the version described by old versions of newexe.h, as distributed in the early MS OS/2 SDKs, and the CHS release of Word for Windows source code. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.		Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. It is also the version described by old versions of newexe.h, as distributed in the early MS OS/2 SDKs, and the CHS release of Word for Windows source code. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.

Dr. Shuppet: /* Mentioned versions of newexe.h and their sources */

2023-01-23T16:39:51Z

Mentioned versions of newexe.h and their sources

← Older revision		Revision as of 16:39, 23 January 2023
Line 1:		Line 1:
	[[Category:Preservation and Documentation]]		[[Category:Preservation and Documentation]]
	'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, in [[Multitasking DOS 4\|Multitasking MS-DOS]], and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used for ~~some Win32s applications~~ and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.		'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, in [[Multitasking DOS 4\|Multitasking MS-DOS]], and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used for Windows 386<ref>IBM OS/2 Developer's Toolkit Version 4.5 newexe.h</ref> and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.

	Compared to the previous MZ format, whose primary feature are relocations, NE introduces the possibility of dynamic linking. Executables linked to the main one are called modules, later also dynamic-link library (DLLs). Non-DLL executables usually have an .exe extension, although a .com extension is also possible. DLLs on OS/2 have an .dll extension (.exe in early version); on Windows, the extension can be .exe, .dll, .drv or .fon.		Compared to the previous MZ format, whose primary feature are relocations, NE introduces the possibility of dynamic linking. Executables linked to the main one are called modules, later also dynamic-link library (DLLs). Non-DLL executables usually have an .exe extension, although a .com extension is also possible. DLLs on OS/2 have an .dll extension (.exe in early version); on Windows, the extension can be .exe, .dll, .drv or .fon.
Line 10:		Line 10:
	The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format and a mandatory MZ stub, still incompatible with newer versions.		The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format and a mandatory MZ stub, still incompatible with newer versions.

	Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.		Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. It is also the version described by old versions of newexe.h, as distributed in the early MS OS/2 SDKs, and the CHS release of Word for Windows source code. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.

	Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.		Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change. IBM OS/2 Developer's Toolkit has newexe.h describing this version of the format.

	NE was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.		NE was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.
Line 18:		Line 18:
	== Header ==		== Header ==

	Various flags, used/unused, undocumented flags ~~(like OS/2 compatability override mentioned in WLO article)~~.		Various flags, used/unused, undocumented flags.

	== Sections ==		== Sections ==

Dr. Shuppet: /* Corrected information about MDOS, OS/2 .dll extensions, and universal real/protected mode NE binaries */

2023-01-23T13:48:21Z

Corrected information about MDOS, OS/2 .dll extensions, and universal real/protected mode NE binaries

← Older revision		Revision as of 13:48, 23 January 2023
Line 1:		Line 1:
	[[Category:Preservation and Documentation]]		[[Category:Preservation and Documentation]]
	'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used ~~in European MS-DOS 4.0 (also known as Multitasking MS-DOS),~~ for Win32s applications, and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.		'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, in [[Multitasking DOS 4\|Multitasking MS-DOS]], and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used for some Win32s applications and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.

	Compared to the previous MZ format, whose primary feature are relocations, NE introduces the possibility of dynamic linking. Executables linked to the main one are called modules, later also dynamic-link library (DLLs). Non-DLL executables usually have an .exe extension, although a .com extension is also possible. DLLs on OS/2 have an .dll extension; on Windows, ~~their~~ extension can be .exe, .dll, .drv or .fon.		Compared to the previous MZ format, whose primary feature are relocations, NE introduces the possibility of dynamic linking. Executables linked to the main one are called modules, later also dynamic-link library (DLLs). Non-DLL executables usually have an .exe extension, although a .com extension is also possible. DLLs on OS/2 have an .dll extension (.exe in early version); on Windows, the extension can be .exe, .dll, .drv or .fon.

	New Executable is also called ''segmented executable'', reflecting the fact it contains segments of code and data to be loaded into memory using segmentation (as opposed to a ''linear executable'').		New Executable is also called ''segmented executable'', reflecting the fact it contains segments of code and data to be loaded into memory using segmentation (as opposed to a ''linear executable'').
Line 10:		Line 10:
	The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format and a mandatory MZ stub, still incompatible with newer versions.		The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format and a mandatory MZ stub, still incompatible with newer versions.

	Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes.		Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes out of the box.

	Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.		Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.

Dr. Shuppet: /* Added TODO for OS field research */

2023-01-18T22:13:59Z

Added TODO for OS field research

← Older revision		Revision as of 22:13, 18 January 2023
Line 12:		Line 12:
	Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes.		Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes.

	Windows 2.1 and OS/2 1.1 introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.		Windows 2.1 and OS/2 1.1 (TODO: look through 1.1 betas for when exactly the change happened) introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.

	NE was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.		NE was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.

Dr. Shuppet: /* Improved history section */

2023-01-18T22:08:42Z

Improved history section

← Older revision		Revision as of 22:08, 18 January 2023
Line 8:		Line 8:
	== History ==		== History ==

	The format ~~first appeared~~ in ~~1985 with the release of Windows 1.0. However, it is implied that it was originally designed~~ for ~~OS/2, whose development started earlier the same year under the name DOS 5.0<ref>https://github.com/lborgav/Historical~~-~~Source-Codes/blob/master/Microsoft%20Word%20for%20Windows%20Version%201.1a/Word%201.1a%20CHM%20Distribution/Opus/newexe.h#L142</ref> and CP/~~DOS, and ~~DOS 4.0 (so-called Multitasking MS-DOS) before that. For~~ Windows, ~~it was the sole executable format~~ for ~~user~~ applications ~~until 3~~.1~~, and continued to be supported until Windows 10 (except 64-bit versions of Windows)~~. ~~For OS/2~~, ~~it had this status until OS/2 2.0~~, ~~and is natively supported~~ in all ~~subsequent versions~~ of ~~OS/2 (except OS/2 for PowerPC)~~. ~~For DOS~~, ~~it was dropped together with the original DOS 4~~.0 ~~being dropped in favor~~ of ~~IBM DOS 4.0~~ and ~~OS/2~~.		The New Executable format was created in 1984 for MS-DOS and Windows, with its main feature being dynamic linking, needed especially for Windows applications to call into GDI and the kernel. It first appeared in Windows 1.0 DR5, dated October 1984, in an early form not identified by modern tools as NE; some, but not all of the files there contain an MZ stub. The next year, Windows 1.0 Alpha introduced an improved version of the format and a mandatory MZ stub, still incompatible with newer versions.

	It was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.		Later in 1985, Windows 1.0 Beta improved the format once more. This version is the mostly compatible with later NE and continued to be used in Windows 1.0, Windows 2.0 and [[Multitasking DOS 4\|DOS 4]] through 1985, 1986, and 1987. Protected mode executables were introduced in 1986 with early versions of [[OS/2 Versions And History#OS/2 Pre-Betas\|DOS 5.0]], utilizing bits in the segment flag word to indicate the ring the segment runs in. Due to API incompatibilities, it is not possible to build a DOS executable to run in both modes.

			Windows 2.1 and OS/2 1.1 introduced the OS field into the NE format in 1988, allowing differentiating between Windows and OS/2 executables (older versions either didn't use the field at all or used it for something else). This was the last major format change.

			NE was gradually replaced with PE in Windows 95 and higher and Windows NT, and with LX in OS/2 2.0 and higher. However, classical Windows up to Me contains 16-bit code in the OS itself, and the same possibly applies to OS/2.

	== Header ==		== Header ==

Dr. Shuppet: /* Mentioned LINK.EXE names and EXEHDR */

2023-01-11T19:04:44Z

Mentioned LINK.EXE names and EXEHDR

← Older revision		Revision as of 19:04, 11 January 2023
Line 22:		Line 22:
	== Linking ==		== Linking ==

	NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE<ref group="note">The name likely comes from Multitasking DOS 4, where the New Executable format first appeared.</ref> or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).		NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE<ref group="note">The name likely comes from Multitasking DOS 4, where the New Executable format first appeared.</ref> or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE (variously known as Segmented-Exectuable Linker and Linker/2) and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).

	== Reverse engineering ==		== Reverse engineering ==

	Windows CodeBack is a DOS-based tool for dumping NE binaries. A newer tool was developed as a part of the open-source Semblance project.		Microsoft SDKs ships EXEHDR.EXE, which can show the header of segmented executables. Windows CodeBack is a DOS-based tool for dumping NE binaries. A newer tool was developed as a part of the open-source Semblance project.

	== Cross-compatibility ==		== Cross-compatibility ==

Dr. Shuppet: /* Category */

2023-01-08T17:41:07Z

Dr. Shuppet: /* Added cross-compatibility section */

2023-01-08T17:40:41Z

Added cross-compatibility section

← Older revision		Revision as of 17:40, 8 January 2023
Line 26:		Line 26:

	Windows CodeBack is a DOS-based tool for dumping NE binaries. A newer tool was developed as a part of the open-source Semblance project.		Windows CodeBack is a DOS-based tool for dumping NE binaries. A newer tool was developed as a part of the open-source Semblance project.

			== Cross-compatibility ==

			In some cases, NE executables for one OS can be run on a different OS, with or without emulation. This happens when the system calls between the systems either overlap, or are implemented in a compatibility layer, and at the same time, the application doesn't use any other specific functions. OS/2 supports running Windows binaries through WinOS/2 since 2.0, and with some limitations through [[Windows Libraries for OS/2]] since 1.2. Windows 1.x and possibly later versions can run binaries for Multitasking DOS 4.0, provided they do not use any DOSCALLS functions or INT 21h API specific to this version of DOS.

	==Notes==		==Notes==

Dr. Shuppet: /* Added note about LINK4 and MDOS4 */

2023-01-08T12:23:11Z

Added note about LINK4 and MDOS4

← Older revision		Revision as of 12:23, 8 January 2023
Line 21:		Line 21:
	== Linking ==		== Linking ==

	NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).		NE executables are created from so-called 80x86 relocatables (also known as [[Relocatable Object Module Format]] and OMF) using a linker, typically called LINK4.EXE<ref group="note">The name likely comes from Multitasking DOS 4, where the New Executable format first appeared.</ref> or LINK.EXE. Older toolchains differentiate betwen LINK4.EXE (produces NE binaries) and LINK.EXE (produces MZ binaries); newer toolchains like Microsoft C 6.00 have only LINK.EXE and the target executable format is controlled by the /L switch (/Lp for NE, /Lr for MZ).

	== Reverse engineering ==		== Reverse engineering ==

← Older revision		Revision as of 17:41, 8 January 2023
Line 1:		Line 1:
			[[Category:Preservation and Documentation]]
	'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used in European MS-DOS 4.0 (also known as Multitasking MS-DOS), for Win32s applications, and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.		'''New Executable''' (also known by its header identification '''NE''') is a 16-bit x86 executable format created by Microsoft in the 1980s. It was used for Windows applications from Windows 1.0 up to Windows Me, including components of Windows itself<ref group="note">Windows 95 and higher also support Win32 applications, which use a different format called Portable Executable).</ref>, and in OS/2 (from 2.x along with Linear Executable). Allegedly, it was also used in European MS-DOS 4.0 (also known as Multitasking MS-DOS), for Win32s applications, and for something called Borland Operating System Services<ref>https://www.fileformat.info/format/exe/corion-ne.htm</ref>.