There are two steps you need to follow in order to create a dApp on Cardano.
- Create the script itself - the on-chain code
- Create the transaction which will make use of that script, ideally make it abstract enough so that any user can interact with you app - this is called the off-chain code
For step 1, your end goal is to have your script compiled into Plutus-core, whose hex representation you can see here, for example.
In order to produce this code, you will probably want some kind of high-level language. You don't write assembly every time you want to create an API, instead you usually write it in C or some language that can be compiled to Assembly.
Currently we have three languages, two of which are still in early stages of development (Aiken and Eopsin):
If you are doing the Plutus Pioneers Program, you probably learned PlutusTx. The advantage of PlutusTx is that it was developed by IOG so it will probably always have the most up-to-date code. In the sense that if we have a new feature added to Cardano (like reference inputs were recently), they will most likely be the first to have it implemented.
In the other hand, as you might have found out already, it is a language extremely difficult to understand, develop and test and I still occasionally scream in my sleep when I remember nix-shell and cabal.
Worst of all, it was not very well-designed in the sense that all other languages mentioned above have significant performance and script size improvements (50% above).
So, honestly, I would suggest you to rewrite whatever script you made using PlutusTx in another language (they are quite easy to understand), because it will keep you from turning mad in the long term.
I have used Helios before and it was very easy to use. You can take this repository as a guide to write and compile the script. I think Aiken will be better in the future, but I have not tried it yet and it is very likely to have bugs since it's earlier in its development phase than Helios.
Finally, for your off-chain code, you will need to create two transactions. The first is the one which sends some amount of tokens to the script with a specific datum and the second is the one which will try to spend that script, providing some redeemer.
Every dApp in Cardano needs to revolve around those two types of transaction. Some more complex ones, however, might mix both types by spending a script and sending some tokens back to that script with a new datum.
The theory behind it is out of scope, but there are currently multiple libraries which you can use to build this off-chain code. Some of which are the following:
Each one is well documented and have their own guides and examples, my advice you would be to use Lucid. PyCardano is great and I have personally used it even more often than lucid, but it builds the transactions in the back-end so you will still need to create a client interface to sign it and submit it. It can be good, however, if you simply want to see your script in the chain and want to test it quickly and easily.