Using OCaml As A Script Language

You can run OCaml scripts directly from the command line with a shebang, similar to bash or Python. This requires making the file executable and using the proper interpreter directive.

Basic Script Setup

Create a file with a .ml extension and add a shebang at the top:

#!/usr/bin/env ocaml

print_endline "Hello world!";;

Then make it executable:

chmod +x script.ml
./script.ml

The #!/usr/bin/env ocaml shebang uses your PATH to locate the OCaml interpreter, making the script portable across systems where OCaml might be installed in different locations.

Important Behavior Differences

OCaml scripts compile entirely before execution. This means:

The entire script is parsed and compiled first
If there’s any compilation error, nothing executes
You won’t see partial results like you would with bash

This is fundamentally different from interpreted languages like bash or Python, where code executes line-by-line and stops at the first runtime error.

Alternative Shebang Approaches

If you need more control or want to load additional libraries, you have other options:

Shell wrapper approach:

#!/bin/sh
# (*
exec ocaml "$0" "$@"
*) 
#use "topfind";;
#require "str";;

print_endline "Hello world!";;

This uses a shell script wrapper to invoke OCaml. The # (* and *) comments hide OCaml code from the shell while hiding shell code from OCaml. This approach lets you load packages via #require directives, though it adds complexity.

Direct path approach:

#!/bin/ocaml

print_endline "Hello world!";;

This works if OCaml is installed at /bin/ocaml, but it’s less portable since OCaml might be elsewhere on different systems.

Passing Command-Line Arguments

To access command-line arguments in your script, use Sys.argv:

#!/usr/bin/env ocaml

let () =
  Array.iter print_endline (Array.sub Sys.argv 1 (Array.length Sys.argv - 1))

Run with:

./script.ml arg1 arg2 arg3

Using External Libraries

For scripts that need external packages, the shell wrapper approach works best. Create your script with library requirements:

#!/bin/sh
# (*
exec ocaml "$0" "$@"
*)
#use "topfind";;
#require "unix";;
#require "str";;

let () =
  let time = Unix.gettimeofday () in
  Printf.printf "Current timestamp: %f\n" time

The #use "topfind";; directive loads the findlib package manager, allowing #require to work properly.

Performance Consideration

If you’re writing scripts that run frequently, consider precompiling critical parts. For simple, rarely-executed scripts, the convenience of direct OCaml execution is worth the compilation overhead. For performance-critical tools, compile to a native binary using ocamlopt instead.

Best Practice Summary

Use #!/usr/bin/env ocaml for simple, portable scripts without external dependencies. Switch to the shell wrapper approach if you need to load packages or want to ensure topfind is available. Remember to chmod +x your script file, and always test that your code compiles before relying on it in production contexts.

2026 Best Practices and Advanced Techniques

For Using OCaml as a Script Language, understanding both fundamentals and modern practices ensures you can work efficiently and avoid common pitfalls. This guide extends the core article with practical advice for 2026 workflows.

Troubleshooting and Debugging

When issues arise, a systematic approach saves time. Start by checking logs for error messages or warnings. Test individual components in isolation before integrating them. Use verbose modes and debug flags to gather more information when standard output is not enough to diagnose the problem.

Performance Optimization

Monitor system resources to identify bottlenecks
Use caching strategies to reduce redundant computation
Keep software updated for security patches and performance improvements
Profile code before applying optimizations
Use connection pooling for network operations

Security Considerations

Security should be built into workflows from the start. Use strong authentication methods, encrypt sensitive data in transit, and follow the principle of least privilege for access controls. Regular security audits and penetration testing help maintain system integrity.

Related Tools and Commands

These complementary tools expand your capabilities:

Monitoring: top, htop, iotop, vmstat for resources
Networking: ping, traceroute, ss, tcpdump for connectivity
Files: find, locate, fd for searching; rsync for syncing
Logs: journalctl, dmesg, tail -f for monitoring
Testing: curl for HTTP requests, nc for ports, openssl for crypto

Integration with Modern Workflows

Consider automation and containerization for consistency across environments. Infrastructure as code tools enable reproducible deployments. CI/CD pipelines automate testing and deployment, reducing human error and speeding up delivery cycles.

Quick Reference

This extended guide covers the topic beyond the original article scope. For specialized needs, refer to official documentation or community resources. Practice in test environments before production deployment.