diff --git a/src/common/scripting/vm/vm.h b/src/common/scripting/vm/vm.h
index 2b7344d5dc..dba1a36de3 100644
--- a/src/common/scripting/vm/vm.h
+++ b/src/common/scripting/vm/vm.h
@@ -534,6 +534,236 @@ inline int VMCallAction(VMFunction *func, VMValue *params, int numparams, VMRetu
 	return VMCall(func, params, numparams, results, numresults);
 }
 
+template<typename T> struct VMReturnTypeTrait { typedef T type; static const int ReturnCount = 1; };
+template<> struct VMReturnTypeTrait<void> { typedef void type; static const int ReturnCount = 0; };
+
+void VMCheckParamCount(VMFunction* func, int retcount, int argcount);
+
+template<typename RetVal>
+void VMCheckParamCount(VMFunction* func, int argcount) { return VMCheckParamCount(func, VMReturnTypeTrait<RetVal>::ReturnCount, argcount); }
+
+// The type can't be mapped to ZScript automatically:
+
+template<typename NativeType> void VMCheckParam(VMFunction* func, int index) = delete;
+template<typename NativeType> void VMCheckReturn(VMFunction* func) = delete;
+
+// Native types we support converting to/from:
+
+template<> void VMCheckParam<int>(VMFunction* func, int index);
+template<> void VMCheckParam<double>(VMFunction* func, int index);
+template<> void VMCheckParam<FString>(VMFunction* func, int index);
+template<> void VMCheckParam<DObject*>(VMFunction* func, int index);
+
+template<> void VMCheckReturn<void>(VMFunction* func);
+template<> void VMCheckReturn<int>(VMFunction* func);
+template<> void VMCheckReturn<double>(VMFunction* func);
+template<> void VMCheckReturn<FString>(VMFunction* func);
+template<> void VMCheckReturn<DObject*>(VMFunction* func);
+
+template<typename RetVal> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 0);
+	VMCheckReturn<RetVal>(func);
+}
+
+template<typename RetVal, typename P1> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 1);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+}
+
+template<typename RetVal, typename P1, typename P2> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 2);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 3);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+	VMCheckParam<P3>(func, 2);
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 4);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+	VMCheckParam<P3>(func, 2);
+	VMCheckParam<P4>(func, 3);
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 5);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+	VMCheckParam<P3>(func, 2);
+	VMCheckParam<P4>(func, 3);
+	VMCheckParam<P5>(func, 4);
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 6);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+	VMCheckParam<P3>(func, 2);
+	VMCheckParam<P4>(func, 3);
+	VMCheckParam<P5>(func, 4);
+	VMCheckParam<P6>(func, 5);
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7> void VMValidateSignature(VMFunction* func)
+{
+	VMCheckParamCount<RetVal>(func, 7);
+	VMCheckReturn<RetVal>(func);
+	VMCheckParam<P1>(func, 0);
+	VMCheckParam<P2>(func, 1);
+	VMCheckParam<P3>(func, 2);
+	VMCheckParam<P4>(func, 3);
+	VMCheckParam<P5>(func, 4);
+	VMCheckParam<P6>(func, 5);
+	VMCheckParam<P7>(func, 6);
+}
+
+void VMCallCheckResult(VMFunction* func, VMValue* params, int numparams, VMReturn* results, int numresults);
+
+template<typename RetVal, typename P1>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1)
+{
+	VMValidateSignature<RetVal, P1>(func);
+	VMValue params[] = { p1 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 1, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2)
+{
+	VMValidateSignature<RetVal, P1, P2>(func);
+	VMValue params[] = { p1, p2 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 2, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3)
+{
+	VMValidateSignature<RetVal, P1, P2, P3>(func);
+	VMValue params[] = { p1, p2, p3 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 3, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4)
+{
+	VMValidateSignature<RetVal, P1, P2, P3, P4>(func);
+	VMValue params[] = { p1, p2, p3, p4 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 4, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
+{
+	VMValidateSignature<RetVal, P1, P2, P3, P4, P5>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 5, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
+{
+	VMValidateSignature<RetVal, P1, P2, P3, P4, P5, P6>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5, p6 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 6, &results, 1);
+	return resultval;
+}
+
+template<typename RetVal, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+typename VMReturnTypeTrait<RetVal>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
+{
+	VMValidateSignature<RetVal, P1, P2, P3, P4, P5, P6, P7>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5, p6, p7 };
+	RetVal resultval; VMReturn results(&resultval);
+	VMCallCheckResult(func, params, 7, &results, 1);
+	return resultval;
+}
+
+template<typename P1>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1)
+{
+	VMValidateSignature<void, P1>(func);
+	VMValue params[1] = { p1 };
+	VMCallCheckResult(func, params, 1, nullptr, 0);
+}
+
+template<typename P1, typename P2>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2)
+{
+	VMValidateSignature<void, P1, P2>(func);
+	VMValue params[] = { p1, p2 };
+	VMCallCheckResult(func, params, 2, nullptr, 0);
+}
+
+template<typename P1, typename P2, typename P3>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3)
+{
+	VMValidateSignature<void, P1, P2, P3>(func);
+	VMValue params[] = { p1, p2, p3 };
+	VMCallCheckResult(func, params, 3, nullptr, 0);
+}
+
+template<typename P1, typename P2, typename P3, typename P4>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4)
+{
+	VMValidateSignature<void, P1, P2, P3, P4>(func);
+	VMValue params[] = { p1, p2, p3, p4 };
+	VMCallCheckResult(func, params, 4, nullptr, 0);
+}
+
+template<typename P1, typename P2, typename P3, typename P4, typename P5>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
+{
+	VMValidateSignature<void, P1, P2, P3, P4, P5>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5 };
+	VMCallCheckResult(func, params, 5, nullptr, 0);
+}
+
+template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
+{
+	VMValidateSignature<void, P1, P2, P3, P4, P5, P6>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5, p6 };
+	VMCallCheckResult(func, params, 6, nullptr, 0);
+}
+
+template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+typename VMReturnTypeTrait<void>::type VMCallScript(VMFunction* func, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
+{
+	VMValidateSignature<void, P1, P2, P3, P4, P5, P6, P7>(func);
+	VMValue params[] = { p1, p2, p3, p4, p5, p6, p7 };
+	VMCallCheckResult(func, params, 7, nullptr, 0);
+}
+
 // Use these to collect the parameters in a native function.
 // variable name <x> at position <p>
 [[noreturn]]
diff --git a/src/common/scripting/vm/vmframe.cpp b/src/common/scripting/vm/vmframe.cpp
index f69b8ea616..e04c6f0d75 100644
--- a/src/common/scripting/vm/vmframe.cpp
+++ b/src/common/scripting/vm/vmframe.cpp
@@ -552,6 +552,76 @@ VMFrame *VMFrameStack::PopFrame()
 	return parent;
 }
 
+//===========================================================================
+// Templates for calling ZScript from C++ with type checks
+
+void VMCheckParamCount(VMFunction* func, int retcount, int argcount)
+{
+	if (func->Proto->ReturnTypes.Size() != retcount)
+		I_FatalError("Incorrect return value passed to %s", func->PrintableName);
+	if (func->Proto->ArgumentTypes.Size() != argcount)
+		I_FatalError("Incorrect parameter count passed to %s", func->PrintableName);
+}
+
+template<> void VMCheckParam<int>(VMFunction* func, int index)
+{
+	if (!func->Proto->ArgumentTypes[index]->isIntCompatible())
+		I_FatalError("%s argument %d is not an integer", func->PrintableName);
+}
+
+template<> void VMCheckParam<double>(VMFunction* func, int index)
+{
+	if (func->Proto->ArgumentTypes[index] != TypeFloat64)
+		I_FatalError("%s argument %d is not a double", func->PrintableName);
+}
+
+template<> void VMCheckParam<FString>(VMFunction* func, int index)
+{
+	if (func->Proto->ArgumentTypes[index] != TypeString)
+		I_FatalError("%s argument %d is not a string", func->PrintableName);
+}
+
+template<> void VMCheckParam<DObject*>(VMFunction* func, int index)
+{
+	if (func->Proto->ArgumentTypes[index]->isObjectPointer())
+		I_FatalError("%s argument %d is not an object", func->PrintableName);
+}
+
+template<> void VMCheckReturn<void>(VMFunction* func)
+{
+}
+
+template<> void VMCheckReturn<int>(VMFunction* func)
+{
+	if (!func->Proto->ReturnTypes[0]->isIntCompatible())
+		I_FatalError("%s return value %d is not an integer", func->PrintableName);
+}
+
+template<> void VMCheckReturn<double>(VMFunction* func)
+{
+	if (func->Proto->ReturnTypes[0] != TypeFloat64)
+		I_FatalError("%s return value %d is not a double", func->PrintableName);
+}
+
+template<> void VMCheckReturn<FString>(VMFunction* func)
+{
+	if (func->Proto->ReturnTypes[0] != TypeString)
+		I_FatalError("%s return value %d is not a string", func->PrintableName);
+}
+
+template<> void VMCheckReturn<DObject*>(VMFunction* func)
+{
+	if (func->Proto->ReturnTypes[0]->isObjectPointer())
+		I_FatalError("%s return value %d is not an object", func->PrintableName);
+}
+
+void VMCallCheckResult(VMFunction* func, VMValue* params, int numparams, VMReturn* results, int numresults)
+{
+	int retval = VMCall(func, params, numparams, results, numresults);
+	if (retval != numresults)
+		I_FatalError("%s did not return the expected number of results", func->PrintableName);
+}
+
 //===========================================================================
 //
 // VMFrameStack :: Call