Cecil.Bridge 1.0.0

Cecil Bridge

Copyright 2026 Cecil Libraries Organization and the Founder(s) Chaosyr

FAQ's/Project Intro

What is Cecil Libraries?

Cecil Libraries are a group of libraries in which extend functionality to many API and provide utilities as a Pseudo-API for several necessity's.

Who is Cecil?

Both a Member of the Vessel Chaosyr, and the Mascot of our Libraries. Mascot wise she is as originally described by Chaosyr "10ft tall, raven, succubus, whom is Bi, Poly, and a Femboy". That's as far as we are with her at the moment, if more details arrive it will be on the Organizations main page, figured we'd fill in for the case anyone's wondering what the logo stems from.

What is this Library for?

This library is primarily for enabling the ability to send messages back and forth between 2 different runtimes. This is intended for usage in the case where you need Modern API's back in a runtime using a severely outdated net version. For example, in the case where you need DSharp+ [net9.0 library] in a BepInEx mod [in this example on netframework3.5]. It's pretty simple to do and use, as long as you have a way of mapping paths for both ends so they can communicate, and having a way they can reach a text file that they would both read, note the library in present wont make the file.

Library Documentation (Bridge)

This will probably be easier to navigate through in the GitHub's Wiki, however this will just be as in depth as the Wiki will be, so everything you need will be within this very file, the Code is also fully commented if you wish to jump straight into coding. If any explanations are weaker than other let us know so we can fix it up!

Initializing a Sender

To initialize a Sender, all you really need is a Path to the other end that you are intending to reach. But let me explain how the Sender is utilized within the Messenger system. The Sender affectively is a path associated with the question of Where do we send the message off to. It's an Object so that it can more easily be changed and for the case that it would be good to have functions under the Sender itself as well.

How do I initialize the Sender?

Well to Initialize it all you really need to do is this;

Sender sender = new Sender([INSERT FULL PATH TO DLL]);

In present you will need to make the logic for fetching the path, it will become much easier when we make Cecil.Pathing_Utils. But while I'm at it here are some useful functions to help guide you;

Assembly assembly = Assembly.GetExecutingAssembly();
string DLLPath = Path.GetDirectoryName(assembly.Location);

The above gets the full DLLPath to where the DLL is located.

Initializing a Receiver

To initialize a Receiver, again all you really need is a Path, this time to the executing run time. The Receiver is used in the Messenger as a Where do messages we send out return back to, this doesn't have to be this run time for record, but its intended for the current runtime running the code to send the message. It's also a Object for the case where we would want to have functions associated with the Receiver itself.

How do I initialize the Receiver?

To initialize it what you do once more is pretty much just this;

Receiver receiver = new Receiver([INSERT FULL PATH TO DLL]);

In present you will need to make the logic for fetching the path, unless you are running from the DLL the messenger will receive the message back from, we'll have better Pathing utilities in our planned library for pathing! But for getting the current executing run time heres what we do;

Assembly assembly = Assembly.GetExecutingAssembly();
string DLLPath = Path.GetDirectoryName(assembly.Location);
Receiver receiver = new Receiver(DLLPath + "\\Orpheon_Bot.dll");

What this does is fetches the full path from the executing run time, than appends the DLL in which it will receive to, in this case Orpheon_Bot.dll.

Initializing and Working with the Messenger

Now this is the not so simple and somewhat complex core component to this whole bridge; the Messenger. It's job is to send messages to the Sender and track when a Message is sent either to it or back to it. Pinging for the message is logic you will need to create in present until we have one built into the project.

How do I initialize the Messenger?

For this one its again just a Object creation;

Messenger messenger = new Messenger([YOUR SENDER], [YOUR RECEIVER], [PATH TO THE TEXT FILE IN WHICH THIS WILL SEND AND RECEIVE MESSAGES]);

Again you'll need to do the pathing logic yourself, and will need to create the path to the destination wanted. Before we move on let me show you how messages are shown in present;

SendsTo;Mesage;Key;SendBackTo
"C:\Program Files (x86)\Steam\steamapps\common\Pony Island\Orpheon\Orpheon_Bot.dll";"eDJ6RCthdml0bEpLbG1wWjFhMlF4L2d6Sno4aUJITmpMblNZVUtzOWtyNENEemtZOWFyM1pNWStQekVpa1RWemVZc0pZMFJmUUFocHRNQ1Q3UXRiNXRBc0dhU0svNUdFdVp3MnZyOFVJaVVMNUk4WFQ0ZGpIRDhNL2xFZitOSkJoS0w2WTlJaFVWU0FKTk1zRDdtbFRBPT0gQXBwbGU=";"x2zD+avitlJKlmpZ1a2Qx/gzJz8iBHNjLnSYUKs9kr4CDzkY9ar3ZMY+PzEikTVzeYsJY0RfQAhptMCT7Qtb5tAsGaSK/5GEuZw2vr8UIiUL5I8XT4djHD8M/lEf+NJBhKL6Y9IhUVSAJNMsD7mlTA==";"C:\Program Files (x86)\Steam\steamapps\common\Pony Island\BepInEx\plugins\Challenges\Pony Island Challenge Runs.dll"

The key on line 1 should help with how to read this but essentially, SendsTo is the string passed in from the Sender e.g. the Path, Message is the Base64 message mixed in with a Key, Key is the base64 key so the system can decrypt the messages, and lastly the end path is where messages will be sent to after the Receiver for where the message was sent does its job if that makes sense.

How do I utilize the Messenger?

To utilize there are a few functionalities you will need to know, let's go through each one!

Object Variables;

These are some variables that would be good to know if your using the Messenger system!

Sender

The sender of the messenger.

Receiver

The receiver of the messenger.

Message

This is the variable in which the received decrypted message will be found within.

MutualFilePath

This is the mutual file path referenced by the Sender and Receiver

Private Object Variables

These are some of the private variables used within the Messenger to help do its job.

PreviousLine

Internal variable used for checking whether the prior received message is the same as the current one.

RetPeices (more or less a sub record)

This is used for certain returns across the class since the lovely Tupples dont exist in this framework. This is used to transfer the key and message back to the function checking for them.

Functions of the Messenger

This is the core section that you'll need for using the Messenger!

Public Void SendMessage(string Message)

This is the function that essentially starts the chain for sending a message. It takes a string representing the exact message you want to send across, all sending and receiving is done via strings.

Private RetPieces EncryptMessage(string Message)

This method essentially makes a random key of byte of size 32-128, encrypts it to Base64, than gets the byte form of the message with the key in front, than takes those bytes and turns it into base64 and returns the base64 key and message.

Private Void StoreMessage(Receiver receiver, RetPeices ret, Sender sender)

This will create or overwrite the messenger file given, and chuck in the key for user reading, and the message sender.SendsTo, message, key, receiver.ReceivesFrom to be read by the receiving end.

Public Bool ReceiveMessage()

This is a check for if a message has been received, and if so, it follows through with the logic of setting the Messengers message to the received message.

Private String DecryptMessage(String message, String key)

This is a method used to Decrypt the message from Base64 and return it back to the receiving check.

How could I ping for Updates in the messenger?

Well there's 2 options we have made in present one a ASYNC the other a Courotine (the Courotine less tested). Mind you the first is written in .NET 9 while the latter is .NET Framework3.5.

Net9.0 Async example

public static string waitForMessageAndReturn(Messenger messenger)
{
    while (!messenger.ReceiveMessage())
    {
        Thread.Sleep(100);
    }
    return messenger.message;
}

public static async Task RunWaiting(Messenger messenger)
{
    while (true) {
        string message = waitForMessageAndReturn(messenger);
        if (message.Contains("Apple")) 
        {
            Console.WriteLine("Received Key 'Apple'.");
            messenger.SendMessage("Heeding your call sir! Here's your key [Bannana]");
        } else {
            Console.WriteLine("Received invalid Key.");
        }
	}
}

You may notice there are 2 functions, and thats absolutely intentional!

WaitForMessageAndReturn() in this example is a function that essentially says Hey when im called let me indefinitely check if theres a message, and if I see one return the decrypted message to the function that called me.

RunWaiting() is a Async method which runs in the background while the rest of the code base runs, what does it do? well it Pings for a message return indefintely and when it gets one it checks the message for a Key for example here Apple than decides what to do in this case say it received the key and send a message back. It can be as complex as needed, it can even be broken into sub functions, classes and modules, this is just a baseline!!

Oh yeah bonus, to call it, it is as simple as RunWaiting(messenger); in your Awake or however you want to initalize the ping check.

NetFramework3.5 Example

public IEnumerator Check(Messenger messenger)
{
    while (true)
    {
        if (messenger.ReceiveMessage())
        {
            if (messenger.message.Contains("Bannana")) 
            {
                PonyIslandChallengeRuns.CodeBaseLogger.LogInfo("Received Key 'Bannana'.");
                messenger.SendMessage("Heeding your call sir! Here's your key [Apple]");
            } else {
                PonyIslandChallengeRuns.CodeBaseLogger.LogError("Received invalid Key.");
            }
        }
        yield return new WaitForSeconds(0.1f);
    }
}

This is the rough Async equivalent for NetFramework3.5; a Courotine.

For record to start it you would do; StartCoroutine(new MessageReceivedCheck().Check(messenger));

How does it work? Well, its essentially a Enumerator which will indeifinitely check if a Message was received, if it was we do the key thing this time the key is Bannana, if it was not we wait a second and loop again.

And thats pretty much all you need to know, if I missed anything lmk on Discord @thincreator3483 ^^

Credits;

• See Code Comments for more precise credits
• Chaosyr/SaxbyMod/Creator; The Sender, Receiver, and Messenger logic and code.

License(s);

Cecil Libraries License (1.0.0)

Copyright 2026 Cecil Libraries Organization and the Founder(s) Chaosyr

In the case where it so falls that a Sub-License and this License conflicts, this License dictates.

Also, any Licenses applied to this Product outside of this License are deemed as Sub-Licenses unless otherwise stated.

1. Key Terms

   This section likely self-explanatory goes over any Key Terms that may be unfamiliar to those looking at this License and seeing if their Project breaks it.

   1. Founder
      1. The person who Originally made this Product. OR under the condition the Product does not come soley from them Definition 2 applies.
      2. The group behind a given Product.
   2. Organization
      1. The GitHub Team that houses all the Products that this License affects.
   3. Contributors
      1. Anyone who has contributed to the Product in any way shape and or form.
   4. Developer
      1. The person in which is using this Product for purposes of developing their own projects.
   5. Mod-Maker
      1. A Developer who is using this Product for purposes of making mods.
   6. Game Developer
      1. A Developer who is using this Product for purposes of developing their own games.
   7. End-User
      1. Anyone who is using this Product as bi-product of it being shipped with a Developers Project.
   8. Product
      1. The project in which this license was applied to.
   9. Project
      1. A developers work, be it from Cecil Libraries themselves, The Founder or A Developers.

2. Founder Clause

   This clause goes over all right's in which the Founder has over the Product this License affects.

   1. The Founder reserves the rights to what can or can not be done with their teams Product.
   2. If the Founder deems necessary to request a Developer's Project, to stop using this Product, or alternatively to alter its usage within The Developer's Project, The Founder has the right to request irregardless, however The Founder may only seek to enforce the usage, if the Developer's Project breaks this License or any of this Product's Sub-Licenses from the Founder or the Contributors.
   3. The Founder has the right to restrict any usage of this Product's associated IP's, for example, any Mascots, Assets, Fonts, Screenshots, or Example Code included in the Product or on the Organization's page for the Product.

3. Contributor's Clause

   This will both go over any right's Contributors have over their code included in the Product, and any requirements for their contribution's to this Product.

   1. Right's of the Contributor

      This sections goes over all right's in which the Contributor has over the usage of their Code within the Product this License affects.

      1. The Contributor may put their own License on this Product, under the condition it does NOT violate any rights given by this License over the Product's usage.
      2. On the case that a Developer breaks your License, it must be sent into headway to the Founder of this Product.
      3. A Contributor's License will only apply to parts of the Codebase in which The contributor is attributed to in the Code Comments.
      4. If A Contributor breaks the License of another Contributor, the Contributor that broke it must adhere to whatever policy the Contributor that made it has.
      5. All Sub Licenses to the Product must be reviewed both by the Organization and by the Founder, before inclusion, this is done to prevent any too heinous of Licenses from inclusion.

   2. Responsibilities of the Contributor

      This section goes over all responsibilities Contributors must follow when working with this Product's Code Base.

      1. The Product's Source Code must remain Open-Source as long as this License stands on this Product.
      2. The Product's Source Code and the Code the Contributor added into the Source Code must have full explanation in the form of XML comments, these comments must Include all the following when applicable; Summary, Param Name descriptions, Returns, and a Remarks containing credits that lead back to The Contributor and how The Founder, another Contributor, or a Developer, may contact zed Contributor if need be in the future.
      3. Any Code that The Contributor deems to be Obsolete must be marked with [Obsolete] in the code base and may not be deleted.
      4. The Contributor's Code must NOT break any functionality of another function, class or project.
      5. Any Commits you make must have a full and complete bullet pointed list of changes made in the Commit.

4. Developer's Clauses

   This section will go over 3 clauses related to Developers along with a generalized set of rights among all Developers.

   1. Mod Makers Clause

      This section will go over usage of this Product by Mod Makers.

      1. If this Product needs to be placed onto a modding site, rather than including it with The Developers Project stand alone and or uploading it as a separate Project, contact the Founder or the Organization to have the Product placed onto the given site.
      2. If the Developer must have the Product shipped with their Project, the Project must list any and all licenses placed upon the Product in some way, shape or form, and on the site hosting the Developers Project, it must state that this Product is shipped with it.
      3. If the Founder or Organization deems it necessary, they may get the Developers Project taken down, with allowance for it to go back up under the following condition; The Project uses this Product from a package uploaded to zed site by the Organization or Founder.

   2. Game Developer's Clause

      This section will go over usage of this Product by Game Developers.

      1. This Product may be shipped with the Developers Project, as long as there is a link back to any and all licenses placed upon the Product in some way, shape, and or form.
      2. If this Product needs to be placed onto an asset store or similar, contact the Founder or the Organization to have the Product placed onto the given site.

   3. Software Developer's Clause

      This section will go over usage of this product by Software Developers.

      1. This product may be shipped with the Developer's Project, as long as there is a link back to any and all licenses placed upon the Product in some way, shape, and or form.
      2. If this Product needs to be placed onto any site in which the Project from the Developer needs it, contact the Founder or the Organization to have the Product placed onto the given site.
      3. The Developer may ask for certain functionality be added to the Product to the Founder or Organization, however there is no guarantee it will happen, quick, or soon, in the case it doesn't get added, you may add it yourself to the Product via contribution, or you may make an Extension Product that extends upon this Product, this License must be shipped with it.

   4. Developer's Clause

      This section will go over usage of this product by all Developers, this clause also applies to the aforementioned Developer's as well.

      1. The Developer must utilize this Product as it was intended, do not utilize it for the purpose of exploiting what it does for unfair gain.
      2. The Developer must not decompile this Product in any way, shape, or form, it is open source for a reason, look at the direct source code if needed to see what the Product is doing.
      3. Try and stray away from reuploading this Product to another site, if it is needed as stated a couple of times now, contact the Founder or Organization for it to be listed.
      4. The Developer may request for functionality to be added, if deemed necessary contact the Founder of the Product for the functionality, but first check if the Organization behind it has another Product that adds the Functionality sought.
      5. Any Developer may contribute to this Product, however they must follow the Contributors Clause as well.

5. End User's Clause

   This section will go over the rights of the End User, i.e. the Consumer who has this Product installed from another Project that uses the Product.

   1. If the End User finds Exploits, Bugs, or any of the likes, contact the Founder directly so it can be resolved immediately.
   2. The user may not alter this Product for purposes of altering a Developer's Project and how it works.
   3. If deemed necessary the Organization or Founder may add more restriction's to this Section.

SaxbyMod's License (Branched off of the MIT License)

Copyright 2026 SaxbyMod

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Additionally, any software that is published, or derived from this project must credit the author(s) of this project. If this is to be published code may not match in a 1:1, there must be some alteration.

Alterations not allowed would be for example changing of comments, stripping of comments, adding of comments, changing variable names, changing variable types, or adding or removing variables that make no change to the code.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.