In this paper, we study secure distributed algorithms that are nearly optimal, with respect to running time, for the given input graph G. Roughly speaking, an algorithm is secure if the nodes learn only their final output while gaining no information on the input (or output) of other nodes. A graph theoretic framework for secure distributed computation was recently introduced by the authors (SODA 2019). This framework is quite general and it is based on a new combinatorial structure called private neighborhood trees : a collection of n trees T(u1), , T(un) such that each tree T(ui) spans the neighbors of ui without going through ui. Intuitively, each tree T(ui) allows all neighbors of ui to exchange a secret that is hidden from ui. The efficiency of the framework depends on two key parameters of these trees: their depth and the amount of overlap. In a (d,c)-private neighborhood trees each tree T(ui) has depth O(d) and each edge e G appears in at most O(c) different trees. An existentially optimal construction of private neighborhood trees with d=O(Δ D) and c= (D) was presented therein. We make two key contributions: Universally Optimal Private Trees: We show a combinatorial construction of nearly (universally) optimal (d,c)-private neighborhood trees with d + c= (OPT(G)) for any input graph G. Perhaps surprisingly, we show that OPT(G) is equal to the best depth possible for these trees even without the congestion constraint. We also present efficient distributed constructions of these private trees. Optimal Secure Computation: Using the optimal constructions above, we get a secure compiler for distributed algorithms where the overhead for each round is (poly(Δ) OPT(G)). As our second key contribution, we design an optimal compiler with an overhead of merely (OPT(G)) per round for a class of "simple" algorithms. This class includes many standard distributed algorithms such as Luby-MIS, the standard logarithmic-round algorithms for matching and Δ + 1-coloring, as well as the computation of aggregate functions.