newObjects (fromerly known as ZmeY soft) newObjects ActiveX Pack1 (AXPack1)
Home Products Docs & Libs
pixel.gif (49 bytes)
Products by category
ALP site
ISAPI filters
Forums (discussions)
Buy direct (RegNet)
Articles and samples
Documentation online

Read more ...
Click here
ALP is implemented as an Asynchronous Pluggable Protocol. It acts like a WEB server but without need of network. It executes WEB applications such as ASP pages and CGI applications. ALP makes Internet Explorer to be server and client. With ALP you can write stand-alone desktop applications, CD-ROM autoruns, use ASP for pure desktop software and still keep your code ready to run on WEB servers too.
Write desktop software in ASP and CGI!
download it


Site navigation
ActiveX components

Run VBScript as service

Also JScript por any other of course! The script behaves as scheduler and globnal system wide COM objuect accessible for all your applications on that machine. You can call it from ASP pages and schedule asynchronous tasks to be performed, ask for their state and much more.

Highlights of the day
Active Label ActiveX
Barcode ActiveX? Much more - the design and printing inside your WEB application
SQLite3 COM ActiveX embeds the SQLite3 database engine and interface to it. Supports paremeterized views and triggers.
Active Local Pages 1.2
Write desktop apps in ASP and CGI. Create wutorun CDs using WEB technologies - yes it is possible!
ActiveX Pack1 family
Desktop Windows, CE/CE.NET and PocketPC! About 50 powerful components for all the Windows platforms.
AXGate 1.1 (new)
Script dafely any ActiveX in Pocket IE. Build applications in HTML and use local resources and components in them.
IE ScriptBar
Create complex toolbars for Microsoft Internet Explorer easier than you may have expected.

Licensing types legend
(M) Single machine license
(U) Unlimited per-company license
(D) Unlimited development license
(S) Special type of licensing

PC Download World

Quick contact

1000 WebSite Tools

Active visitors
Suggested links
Suggest this page to the other visitors. Click the button below to place this page in the list above .

 newObjects ActiveX Pack1 (AXPack1)   
Price: FREEWARE Discount for resalers FREEWARE
Information Download Buy
Storages and Files
Hosting Active Scripts
Config, INI files and Registry
AXPack1 family samples
Download (SFX 1.8MB PC/PPC)
Download (ZIP 3.1MB PC/PPC)
PC Only (SFX 0.8M)
PC Only (ZIP 1.2M)
CAB (Pocket PC ARM)
CAB (Pocket PC SH3)
CAB (Pocket PC MIPS)
All the downloads


Related products and tools
The home pages of the particular  AXPack1's components

More about the networking part of ActiveX Pack1 family.
SQLite COM database /
SQLite3 COM database
More about the SQL database part of the ActiveX Pack1 family.
Cryptography made easy on low level. 

newObjects Development Library - combined documentation.

Products using AXPack1 as run-time library

Active Local Pages
Write desktop applications in ASP and CGI. (the pack is also included with it).
Script any ActiveX in Pocket IE
Script service
If you want to build Windows NT/XP service in script.
ASP Compiler
Compile scripts in DLL through VB or/and Create active projects to generate static content. Uses ActiveX Pack1 as run-time library.

Development tools from other vendors offering AXPack1 as add-on/integral part

NSBasic - form based (VB-like) programming environment for desktop and CE.


CE App manager Inovker
You may need this for your Pocket PC installations.

A Family of COM objects that provides ultimate set of functionality

The newObjects ActiveX Pack1 family (AXPack1 family) contains over 50 COM classes mainly designed for scripting environments (such as ASP, ALP, WSH, IE etc.) and mixed applications where the scripts do part of the work (such as C++ applications that can be scripted, applications that support plug-ins etc.).

The family provides components in areas such as file access; binary data management; custom script hosting; utility collections (dictionary objects); string formatting, UDS (Universal Data Structures - an XML altrernative) that can be used for data storing, configurations, data transfer; system information and tasks; network connectivity; self-dependent, zero-configuration SQL database engine; composite objects - write your own COM classes in script, cryptography and many others.

The AXPack1 family is built as a foundation over which the developers can create extensions, implementations of specific features and technologies by utilizing the AXPack1 family features thus lowering the costs and obtaining maximum cross-platform and cross-application compatibility. The family components are planned carefully to provide universal features on the right level so that the developers can build over them more specialized solutions without need to dig deep into the OS API. For instance using the binary data and streaming/networking functionality it is possible with feasible effort to implement protocols like  SMPT,PO3/IMAP fully in script without need to resort to any other external components.  

The structure of the family. Currently the AXPack1 family consists of:

ActiveX Pack1 core (AXPack1). It is implemented in a single DLL: newobjectspack1.dll. It contains over 30 COM classes that cover core OS functions, frequently needed utilities and other features that are often used together. It is self dependent and is compatible with Windows 95/98/ME/NT4/2k/XP/2k3/Vista and later and with Windows CE 3.0/CE.NET 4/5 and later (including Pocket PC and Smartphone editions). See the list of the components below

NetStreams - Implements TCP/IP and IRDA functionality over WinSock 1.1 and is compatible with all the Windows versions the core (AXPack1) supports. It is implemented in a DLL named: NetStreams.dll. Depends only on the AXPack1 core (e.g. you need to have installed the both DLL-s if NetStreams is to be used).

SQLite COM / SQLite3 COM  - Implement a fully functional, self-dependent, zero-configuration SQL database engine. It is compatible with all the Windows versions the core (AXPack1) supports. Implemented in a DLL named: SQLITECOMUTF8.DLL and SQLITE3COMUTF8.DLL respectively. Depend only on the AXPack1 core (e.g. you need to have installed the both DLL-s if SQLite COM is to be used). From the both obviously SQLite3 COM is more advanced.

HashCryptStreams - Cryptography library. The aim of the initial version is to establish a programming interface for the most frequently used kinds of algorithms on lower level than the Windows Crypto API. It is completely independent of the cryptography libraries of the OS. The first version comes with support for DES/3DES, AES, SHA1, SHA256, MD5, RSA. Having a well-defined programming interface we will add many more algorithms in the next issues of AXPack1 thus enabling you to use them without any code changes other than specifying the name of the algorithm (note this is not the case with RSA - the public key cryptography algorithms are specific and it is not possible to devise a common programming API for all of them on the algorithm level).

The  AXPack1 family uses the AXPack1 core DLL as a kernel and all the other members of the family make use of it in to some degree. However none of them depends on anything outside. As the non-core members of the family provide more specific features the developers may choose which DLL-s are needed for their applications and they must include the AXPack1 core DLL and whichever members they actually need. Of course, there is nothing wrong in deploying the entire family with the application as long as the size is not a concern, even if some DLL-s will remain unused. 

The AXPack1 core DLL (newobjectspack1.dll) is a good replacement for FSO (FileSystemObject) and is also available for Windows CE/Pocket PC/CE.NET as well. Some of the other classes resemble a functionality you may know from components of other vendors. However the similarity is not the only virtue of AXPack1 family! The AXPack1 family is designed with universality in mind and where the similar components you already know provide the feature you need in a narrow area AXPack1 provides it in a form usable in much more scenarios. One of the best examples is the Storages and Files group of components (in the core DLL) which in contrast to FSO provides the same set of features not only for files but also for memory streams, OLE storages, network connections (with NetStreams), transparent encryption/decryption and can do the same with 3-d party stream and storage objects. While FSO gives you only text based access the Storages and Files group gives you also binary and record based access (known also as flat file or also as database like). The internal integration between many of the components allows better performance and some unique features in otherwise familiar areas.

The documentation is NOT included download packages. To access the documentation you will need to download the  newObjects Development Library separately. This library contains combined documentation for all our the products which means there are cross-references you can follow without need to download additional documentations. Even if you do not plan to use any other product of ours some of the illustrations of the AXPack1 usage in them may be useful for you in other environments as well.

What's new 

Last update September 2006

New modules added:
- SQLite3 COM - SQLite3 based database engine - see more here.
- HashCryptStreams - the initial version of cryptography support in AXPack1. Comes with several hash and encryption algorithms and establishes an algorithm independent programming interface.
- Some new features added to SFBinaryData object.
- Various other small additions and improvements.

- CE.NET binaries have been re-compiled and do not need ATLCE DLL any more.
- Special edition for Smartphone 2003 and later has been added with Micro Script Host designed for smartphone user interface.
This update is minor - only developers who need files for non Pocket PC based CE.NET devices need it.

- StrngUtilities object has been added. Powerful string formatting compatible with the printf functions from the standard C libraries but extended with many additional useful features.
- Improved behavior of the composite objects (now they can be used as ASP objects more easily), COMScriptThread minor issue has been fixed.

Version 2.4.2. 
- COMSleeper, Event, Mutex and Semaphore objects have been added to aid muti-threaded and networking (see NetStreams) programming.

Version 2.4
 - COMScriptThread - Easy and cross-platform compatible way to run script in background thread(s)
 - Full port to Windows CE/CE.NET
 - SFBinaryData class added to support advanced operations over binary blocks of data
 - UDS tools (ConfigFile class) now support wide strings and unsigned values.
 - Byte ordering parameters are supported by all the classes where data in foreign byte order can be read (e.g. you can manipulate data that uses big endian values).
 - Micro Script Host is extended with a few methods

Note: From 2003 The ActiveX Pack1 core DLL replaces some of our components previously available as separate DLL-s. It now includes all of them in the AXPack1 core DLL. This concerns the following DLL-s distributed separately before 2003: newobjectscollections.dll, ASPIniFile.dll, scphost.dll. IF you are using any of them you can install the AXPack1 family and delete them safely - all the applications that use them will continue to work properly. 

Some Highlights

We change this part of this page from time to time to point out certain interesting parts of the family. 

The pack is a base on which you can build your own components and libraries.

The composite objects is a technique that allows developers build new COM components in Active scripts (VBScript, JScript etc.) and/or other languages in combination (for example part of the component can be in script and part in C++ or VB). Using the existing library components the developer can produce more specialized components. For example an upload handling components (SFStream and VarDictionary provide all the needed base features - the rest is simple enough for a script language - mostly data organization). Instead of having a boxed upload component this way you can build something that is both closed (when you just want to use it) and opened for evolution (when you want to extend it). 

The threading components allow the developer run scripts or objects as background threads. For example this allows ASP WEB applications to perform tasks otherwise inappropriate for the WEB. for example COMScriptThread can be created and kept in an Application variable. Then some pages may schedule tasks for the script loaded in it and check if their tasks are finished in another request. A good example is a scenario where you need data mining - you need to extract summary information from the database in a way that is not the primary target for the database design and thus requires considerable time. Another sample is custom content indexing or fetching and caching network resources used in the ASP application.

The SFxxxx components (Storages and Files sub-set/group) implement abstract stream/storage manipulation which allows their features to be applied over external objects with similar behavior. For example there is a NetStreams module member of the pack's family which allows network connection to be treated as stream. In this case you will need to call one Connect method to establish a connection and then you need just to attach a SFStream to it and read/write it in text/binary or record oriented mode the same way you do this with files.

Micro script host

Many developers know the difficult situation in which you have no script host application on the PC. On the Pocket PC platform there is no such standard tool. This is the purpose of the simple Micro script host included with the pack. It is an application offering the same functionality on PC and Pocket PC/Windows CE.NET device. The interface supplied is simple but enough for many handy tasks a developer or power user may want to perform. 

Record based file access or as many developers know it "flat file" access or "database-like" access to files.

If you know some of the compiled languages probably you miss this in ASP and ALP - random access to records in a binary file - just like in a DB table. SFRecord and SFField objects provide it and, again, not only on files but on any stream. If a resource behaves in way similar to a file you are able to use it like a DB table, define records and write/read them at any position (if the stream is seekable) and sequentially (on any stream).

What for? Access from script application (ASP, WSH, ALP, etc.) non-text file formats and not only access but work with them as the C++ or VB applications do. Use binary files to store the application data if you want to avoid DB (sometimes deployment requirements make it more than reasonable). Create scripts for import/export from/to files created by other applications and so on.

Hosting scripts

There are the ScriptManager2 and the ScriptAggregate components. You can build with them custom scripting environments for minutes - that is the idea. Imagine how much flexibility will gain a VB or C++ application if you are able to move part of the logic outside in easy to replace scripts. And all the mess with the scripting interfaces is transparent - you need only to add the environment objects, put some script and the host is ready to go. 

What for? Almost any project will need twice less work if the logic is outside and only the core functionality and critical calculations are in VB or C++ part. The script could play different roles - configuration role, driving the components in the application to do their work, extend the application, allow the user to program macros and extensions. And why not use it in another scripting application? One scripting application (for example ASP page) may construct a host, tune it and run another script which will run in an environment much convenient for the particular task than the ASP page may offer. While the popular environments such as Java and .NET seem to offer such an oprotunity the fact is that they are most often inconvenient because they cannot separate the application in something hard to code and something simple and thus split the work between different kind of developers. Still using the available COM gateways in such environments you can add active scripting functionality to applications based on them.

Universal collections/dictionaries

VarDictionary and UtilStringList implement multipurpose collections. Compared with the Dictionary object from the standard library coming with VBScript/JScript  they offer its functionality and much more. Behavior can be tuned as appropriate, it is easy to keep collections of collections in memory - tree like data structures. There are cloning and searching methods which allow in a single line complex operations over trees of data. Tuning - you tell the collection how to behave: what to enumerate the values or their names, allow/disallow assignment ( collection("SomeValue") = newValue ), allow/disallow unnamed values etc. If the collection contains sub collections you can just call FindByName or FindByValue to find values or sub collections in depth.

What for? First they are used by other objects returning structured data - for example registry branches, directory contents etc. You are able to construct and manage complex structures of data in memory. Why use XML just because its DOM objects (if no XML is to be parsed)? You are able to construct exactly what you need. Keep various data in memory in structured form with ability to find what the application needs.

INI files, Registry, other configurations

ConfigFile allows you to manage custom configuration files, registry and data stored in binary files through a single function call. One call is needed to load entire tree of various settings and other values in the memory or save it back to the same or another storage.

Additional samples and information sources - Samples/articles that often involve usage of components from the pack.

The included documentation (ndl.chm) and samples installed by the setup program.

In Active Local Pages product where the library is included as standard run-time library. Most of the samples can be used without changes on Microsoft IIS as well.


newObjects ActiveX pack1 family is a freeware! You can use it wherever you need it or include it with your applications if they need it. We will be glad to learn about your usages of the package, but you are not required to inform us!

Is there support for it? Yes - the ActiveX pack1 family is a standard run-time library for our commercial products. Therefore it is a vital part of our work and as core components for many other products is tested very carefully. If you need support you will receive it by e-mail if you have a development oriented license for one or more of our commercial products including it. We will try to answer also questions from users who have no such license but of course our customers will have priority.

Versions higher than 1.0 of the HashCryptStreams DLL may require license for part of their functionality. However it is a strict rule for us to keep freeware what once has been such! Therefore what is free at the moment you notice it will remain such. 

You want to gain support for the AXPack1 family separately  - contact us. 

System requirements:

PC version: Windows 95 and later, Windows NT4/2000/XP/2k3 and later. On Windows 95/N4 IE4 is recommended (as it ships with DCOM update which allows extended usage).

Windows CE version: Windows CE 3.0, CE.NET 4.0 or later, with standard SDK support. 

Special versions for older and specific CE distributions may be requested/available, but they may not be able to support all the features on CE versions prior to 3.0.


Components in the pack 

The list is in alphabetical order. See the notes description after the list.

Class Reference in NDL Information and articles Notes
core - newobjectspack1.dll
COMApartment Reference,
COMThread Reference,
(UDS Manager)
See Config, INI files and registry CBF
CustomLock Reference,
IniFile* Reference See Config, INI files and registry CBF
NodeInfo Reference P
Pack1Creator Reference,
ScriptAggregate Reference CBF
ScriptManager2 Reference See Hosting active scripts CBF
SFBinaryData Reference,
SFDirStorage Reference,
SFDrive Reference,
SFField Reference,
SFFileStream Reference,
SFFilter Reference,
SFInfo Reference P
SFMain** Reference,
See storages and files CBF
SFRecord Reference,
SFShellLink*** Reference,
SFStorage Reference,
See storages and files CBFP
SFStream Reference,
See storages and files CBFP
TypeConvertor Reference
UtilStringList Reference,
VarDictionary Reference,
VaryDisp Reference,
VaryDispCreator Reference,
VaryDispCtx Reference P
COMScriptThread Reference,
COMSleeper Reference   CF
Event Reference   CF
Mutex Reference   CF
Semaphore Reference   CF
StringUtilities Reference   CBF
SQLite COM Reference See its page CBF
SQLite3 COM Reference See its page,
NDL-SQLite3 COM functions and session parameters
Parameters Reference P
NetStreams - NetStreams.DLL
  See its page
NSMain Reference   CBF
SocketStream Reference   CBF
SocketAddress Reference   CP
IRDADeviceInfo Reference   CP
SockOpt Reference   CP
SocketSelectHelper Reference   CP
HashCryptStreams - HashCryptStreams.DLL
  See its page
HashObject Reference   CBF
SFStreamDigest Reference   CBF
Symmetric Reference   CBF
SFStreamCrypt Reference   CBF
RSA Reference   CBF
BigNumber Reference   CBFP

* - Not supported on Windows CE/CE.NET
** - Some members have important platform notes
*** - Not supported on all CE/CE.NET based platforms

C - Creatable
B - "Both" threading
F - "Free" threading
A - "Apartment threading"
P - Parent threading - inherits the threading model of the object that creates (internally) and returns it.
- The link is to the online copy of NDL (newObjects Development Library)

On Windows CE there is no support for Apartment threading. To gain compatibility the Class ID/ProgID that are registered for this threading model on the desktop Windows OS-es are registered as "Both" on Windows CE. For example the VaryDisp class has Apartment, Both and Free threaded ProgID/ClassID on Windows CE the ID-s for Apartment and Both will both be registered as "Both".

The ActiveX Pack1 family is suitable for client side and server side usage as well. Note that most objects (for which it makes sense) have normal and free-threaded ProgID/ClassID. In certain applications (mostly on servers - IIS is a good example) there is a benefit in using free-threaded components in some places. Also there are applications that need free-threaded COM objects explicitly. If there is such a reason - use the free-threaded versions of the COM objects.

Note that SQLite COM performs its operations in a single thread (no matter which - the thread over which it is called). I.e. you have as much potential parallel operations as is the number of SQLite COM objects opened - you can open the same database from several such objects. This means that the most effective way to use it in a multi-user and in a single-user application is a bit different. While in a single-user application you can open one connection and perform everything through it, on a server it is better to open connections as needed and close them immediately after completing the task (this operation is very fast). Keep this in mind if the code you write will work in the both scenarios and try to find a design line that will make it possible to get best performance in the both cases. This is true for the most in-process database engines and is caused by the typical specifics of the single-user and multi-user operations. While one user may perform parallel operations they are most often related to the same data relations and limiting the connections to one helps the db engine optimize its work (this has impact over the internal cache, the indexing and so on). With multiple users it is important to minimize the locking time for any part of the database even if this will slow down some operations a little.

Copyright newObjects (ZmeY soft) 2001-2005