Draft 1.01:

Sections: Status -> Approved

1.) EntityScript™ Overview - Overview of the project

2.) .entity/.ds Lookups - Overview of basic .entity and .ds file relationships. An overview of each file.

3.) Special File Types - Overview of special types of methods, files, and types in C.ORE™

4.) Log File Types - Overview of Logging within C.ORE™

5.) Using OpenPackager™ - Overview of the OpenPackager™ project and details regarding using the sub-system for organizing the base system and addons.

6.) Locations - Overview of various parts of the IPDVC™ file system

7.) System Audits - Overview of various audit mechanisms present in C.ORE™ and how to use them.

8.) C.ORE™ Scripts - Overview of scripts that run in C.ORE™, the purpose they have, overview of some scripting philosophy, and some usage examples.

9.) Startup - Step-by-step process of startup routines and how to extend them

10.) C.ORE™: AirEP™ file system (Access Identity Ring Entertainment Platform: AirEP™ - Understand more about the Access, Identity, Ring

11.) Keys: Each of the built-in keys that can be used to retrieve meta-information in C.ORE™

12.) How-to: Additional Notes

13.) Moderation: Basic moderation principles

14.) Social Pledge: Basic social-pledge for your interface and who you interact with

15.) Disclaimers: Basic recommendations for your interface and dealing with various types of commerce

16.) Additional Resources: Dig deeper into the technical stack, program methods, variables, and other happenings within CORE.HOST™


C.ORE: AirEP File-system (Access Identity Ring Entertainment Platform: AirEP)

The following 3 instances comprise the makeup of the IPDVC (Internal Processing Deployment, vetting-system, and Creator.


When the Ring gets invoked by the handler inside of the Identity folder, this silo becomes a read only setup-slug. This folder controls I/O read/write access to your system while it interacts with C.ORE™ and while its being controlled by any stateful object also using Access at the same time. All system bindings happen through Access.

The Ring is made up of 3 unique parts and no more, and they're all carried in some form of statefulness by Access. These two parts work together to handle stateful machine definitions. These same definitions help keep your instance secure according to various preset operator needs. If you'd like to challenge convention, please save your passions for the Identity section which focuses on expression.

Access, like Ring are static systems inside of C.ORE™, similar to a kernel, except they set no machine interfaces by themselves. They only exist in Memory once state is achieved.

This section is meant to mimic the minimal code architecture of a micro-kernel, but it is mapped and activated differently because there are more parts. The convention is simply to achieve statefulness and control of the operator instance/user-space, not to provide extended peripherals or achieve low level things like power supply and CPU definitions. All of those things are assumed. So this is operating above that layer. The main advantage of these mock-virtual kernels like we have here is their small size and enforcement potential for various items in user-space. You could define a tight "no more and no less" system with a few hours of thinking. All extensions happen in OpenPackager™, which also interacts with Ring and Access to determine credential and ownership values for various operating items. It mainly attempts to confirm something in memory is as intended before committing more details to disk. Access, Ring, and what runs with them - OpenPackager™ exist mostly in non-perm or higher system routines, mostly existing in memory only.

The RING is no different once settings are read on startup. Mostly this following statement will hold true: once things are setup, the RING can scale an instance on one machine to many machine safer than a human could.

Separate instances of C.ORE™ can propagate through an automatic fabric provided.

There isn't meant to be any sort of changes to the ACCESS/ structure or configuration ever once the entity is "up". That's why the ACCESS section works on startup only to encode the RING with instance specific variables to define all of these decisions for now, including interfacing with the system configurations necessary to make this happen, log them, work with the other functioning parts of the program, etc.

ACCESS like RING exists with explicitly defined sets of directions in a .entity file that's only readable by certain program types. They pull from a Data Slug ( .ds ) file elsewhere. These slugs are either privately owned and locally 'slugged' or publicly available to anyone at https://CORE.HOST/community/

The C.ORE™ program sits inside of your home directory by default. If you're just starting it for the first time, you can put it there and do these three steps

1. Build
2. Setup the Filter
3. Add Programs (no extensions in version 1)

ACCESS naturally gets to interface with your defined data too, but always indirectly. This is where we will pick up more with next time.

Additional Features: ACCESS


Active qualifiers will allow you to narrow a search down with entity script.

EntityScript™ is a syntax lookup engine that operates in a complex manner but presents a simple interface to the operator. The "ACTIVE QUALIFIER" terminology specifies the responsiveness of this lookup system which operates in almost real-time. If we submit the search form, the Access and Ring sections are invoked as a pairing then the taken string input from the box is translated by other sub-systems which already hold qualified results. If the filter text is in the queue, it'll then be returned. That's the most basic method. It can get much more complex, but we won't get there during this explanation version. We're giving you the opportunity to narrow down information more quickly soon and we'll have it documented.

The C.ORE (Cognitive Operations Resource Enclave™) system facilitates the in memory safety checking for this to function and both place and retrieve data onto disk safely on a host machine.


Also, All qualifiers are created in a .entity/.ds relationship defined on your system.

This should plug in directly on top of your system without headaches following the installation guides. When an OpenPackager™ instance wants to be added to the "RING" location which has Access, the package will need to have a .linker or program defined privileges.

You can set this all up in a .entity file linking back to the .linker file which is gone over briefly in a previous page.

We never make calls to protected slugs by calling the .ds file directly. We want to do a linker lookup, which then calls the file based off of it's own protected lookup system and permission specifications.

More on preparing .ds files:

1. Get the file into line-by-line format: i.e. all lines represent one entity of data with various attributes defined elsewhere in a .entity file.
2. Make sure the file is UTF-8.
- ODS, XML, and other files can be used, but we want this in a Data Slug file, or DS file.
- Essentially a CSV but with a modified header and cell type that have an enforced encoding and .entity defined attributes. The file is built entirely for context controls available elsewhere and for block manipulation activities.
3. When the data is finished being prepared in line format, save as a CSV file (This has been found easiest if no other tools are available or your system isn't teched out. You could save it directly as a .ds file too.
- If you're in a CSV type editor, you can do this:
- Select Save As
- add options
- Surround everything in quotes
- Format type should be set to UTF-8 text version
4. Open the CSV in your editor
5. Create a .DS empty shell in UTF-8. This file can receive a dump from the CSV you have open, or simply rename the file .ds if your system is formatted correctly to handle the raw dump.
- If dumping the data from the CSV into the DS file, copy and paste and then save the next file.
7. Exit
8. Verify the file using core_gather.test()
- Pandas can be use as an extension to read the file as a CSV type because its backwards compatible and will read/write to .ds/.entity systems as well.

More Examples of cleaning data from complex types into line format. Sometimes you'll have to convert random file types too.

A QUALIFIERS.entity file can be created to your own specs to help you achieve this for a variety of known data cleaning methods. There will be more meta details for the format there to look into soon too. To become accessible to the qualifiers area, you'll need to be added to the corresponding .ds holding this info through the Access/Ring process. This makes sure that .entity/.ds files can only be read while a system is on and by the correct user-space parties.

Each entry in the QUALIFIERS.entity file would be some known routine for taking in and ingesting data. The goal isn't to need them, but they're meant to help.

In this case, the QUALIFIERS.ds file can act as a mask for even deeper rooted DS files containing specific program logic or nested permission management.


This is some mock up basic of how you could branch routines into more processes for whatever needed reason.

id, qualifier_id, openpackager_UID, openpackager_NAME, openpackager_ENTITY_FORMAT
1, 1, "OP:BASICS", "Basics", DS4000000.entity
2, 2, "OP:SHNLUHLPHNSHEL", "EventLolli", DS7000001.entity

-->>>welcome to eventlolli
-->>>setup_game by pressing 0
-->>>0 selected, what kind of game would you like to create?
--->A.) Giveaway
--->B.) Sweepstakes

ACTIVE QUALIFIERS Also work by typing in various Keys. All the Keys will eventually be up here. ESX is one, ESV another.

In this case, ES is a designated precursor that activates a blanket matching search in applications that have this enabled such as BrowseMeh™. Anyway, the main point is - it's all managed by Access/Ring. Then there is the Identity!


All static assets utilized by C.ORE™ are displayed through a similar linkage described above. You can use IDENTITY/ to separate and optimize them. You'll be able to keep things like instance photos, 3D assets, various digital arts, and other advertisements here that you may want to launch. It's like a basic publishing review and organizing mechanism for YOUR stuff only. Other peoples stuff goes in the FILTER/

Identity Overview:


Anything that's run by a program in C.ORE™ is 'ACCESSED' and 'RUN' in .CORE/OPENPACKAGER/

This includes:

SECURITY: Authorized Resources Only: Required clearance: 1FA

1. You are allowed to participate in the studies or templates that you have been authorized to by specific asset owners owners only
2. You agree to purge all non relevant materials or unowned assets from the machine during manual machine filtering
3. You agree to make available your findings and datasets with relevant authorized persons upon request from lawful activities
4. You agree to use only the materials in this section that are licensed properly according to the "New Entity Operations Licensing Handbook"
5. Do not corrupt source files - always make a branch and label it -
- - BranchName+\
Example first branch first version: GreatestProgram_1_A 6. A master table should be created and maintained for each file and searched for there. The framework provides ways to do this properly. Manual lookups are discouraged. Consult additional readings for the correct lookup methodologies moving forward


The location used to setup various system access commands. Some examples would be adding and deleting users, turning off base-features, and doing other policy enforcement. That's RING in a nutshell.

The RING needs:
1.) User-supplied Information: The Ring is the interface-access module, but it doesn't function without your initial commands.
- Each RING part is toggle-based through a front end. This runs in core_FRONTEND.py. This helps you manipulate various interface options and system functions without installing risky dependencies.

2.) BuildSpec - The BuildSpec is a status oriented directory structure meant to read the status of your machine state and provide contextual support based on that. This helps the operator control system and graphical functions without messing with anything near the Kernel. This establishes more or less a basic set of definitions simulating emulator devices.

BuildSpec: Additional Details

This can include documentation for programming languages and additional support materials intended for quick recall/fact access later on.
The Audit Home directory or "AUDIT_HOME" either prints STATUS.OKAY, or STATUS.FAULT. STATUS.FAULT occurs when the internet retrieval data frame can't connect to the defined 'Universe meta-storage' existing on the network. This can be because of a write access error or a misdirected extension, but it usually just means your offline.
The Documentation section will have the base/standardized documentation for any software running within the machine in HTML form.
The Hardware section stores .so compiled files that can talk directly to your hardware device and handle devices. These devices can be defined within the OPENPACKAGER/ folder. You'll find more information in the documentation on that there soon.
The IPDVC is the Internal Processing, Deployment, Vetting-System, and Creator. It contains the /tmp directory structure defined in the IPDVC.entity file and destroys itself when the machine state is STATE.OFF. STATE.ON can only occur if the IPDVC™ contains a bin with the proper .so file extension to start the instance on the operating system. The Learning section isn't active and was removed from early versions. A list of documents intended to help operate the machine - that was the vision. But it really only made sense as an item inside of FILTER/ unless you could find a way to eliminate the need for other peoples information/data to make it useful.
The Operations section contains prebuilt or stored code-snippets or operating syntax that can be accessed through the machines 'emulator-interface' while it's state is 'STATE.ON'
The Packages section of the Ring contains any desired package according to a semi-controlled format. These are managed through OpenPackager™ in the corehost or external folder. Upon the state of the machine turning to STATUS.ON, the packages folder will populate with sym-links through a temporary ln - assignment. This will be unassigned when the status of the machine is STATE.OFF
The Setup Box section gives you a way to store prebuilt content and other moderation rule sets. You can then force the machine to comply with those rules. This way you keep yourself clean from potential licensing and usage headaches.

C.ORE™ operates off of a extensible key-based system too. Check out some of the current lookup Keys